Coverage Report - com.googlecode.sparkleg.SparqlParser
 
Classes in this File Line Coverage Branch Coverage Complexity
SparqlParser
92%
13283/14321
25%
1244/4956
11,626
SparqlParser$DFA4
95%
22/23
N/A
N/A
11,626
SparqlParser$add_return
0%
0/2
N/A
N/A
11,626
SparqlParser$additiveExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$additiveOperator_return
100%
4/4
N/A
N/A
11,626
SparqlParser$aggregate_return
100%
4/4
N/A
N/A
11,626
SparqlParser$anon_return
100%
4/4
N/A
N/A
11,626
SparqlParser$argList_return
100%
4/4
N/A
N/A
11,626
SparqlParser$askQuery_return
100%
4/4
N/A
N/A
11,626
SparqlParser$baseDecl_return
100%
4/4
N/A
N/A
11,626
SparqlParser$bind_return
100%
4/4
N/A
N/A
11,626
SparqlParser$bindingValueList_return
100%
4/4
N/A
N/A
11,626
SparqlParser$bindingValue_return
100%
4/4
N/A
N/A
11,626
SparqlParser$bindingsClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$blankNode_return
100%
4/4
N/A
N/A
11,626
SparqlParser$booleanLiteral_return
100%
4/4
N/A
N/A
11,626
SparqlParser$brackettedExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$builtInCall_return
100%
4/4
N/A
N/A
11,626
SparqlParser$clear_return
100%
4/4
N/A
N/A
11,626
SparqlParser$conditionalAndExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$conditionalOrExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$constraint_return
100%
4/4
N/A
N/A
11,626
SparqlParser$constructQuery_return
100%
4/4
N/A
N/A
11,626
SparqlParser$constructTemplate_return
100%
4/4
N/A
N/A
11,626
SparqlParser$constructTriples_return
100%
4/4
N/A
N/A
11,626
SparqlParser$copy_return
0%
0/2
N/A
N/A
11,626
SparqlParser$create_return
0%
0/2
N/A
N/A
11,626
SparqlParser$datasetClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$deleteClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$deleteData_return
100%
4/4
N/A
N/A
11,626
SparqlParser$deleteWhere_return
100%
4/4
N/A
N/A
11,626
SparqlParser$delete_return
100%
4/4
N/A
N/A
11,626
SparqlParser$describeQuery_return
100%
4/4
N/A
N/A
11,626
SparqlParser$drop_return
100%
4/4
N/A
N/A
11,626
SparqlParser$existsFunction_return
100%
4/4
N/A
N/A
11,626
SparqlParser$expressionList_return
100%
4/4
N/A
N/A
11,626
SparqlParser$expression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$filter_return
100%
4/4
N/A
N/A
11,626
SparqlParser$functionCall_return
100%
4/4
N/A
N/A
11,626
SparqlParser$graphGraphPattern_return
100%
4/4
N/A
N/A
11,626
SparqlParser$graphNode_return
100%
4/4
N/A
N/A
11,626
SparqlParser$graphOrDefault_return
0%
0/2
N/A
N/A
11,626
SparqlParser$graphPatternNotTriples_return
100%
4/4
N/A
N/A
11,626
SparqlParser$graphRefAll_return
100%
4/4
N/A
N/A
11,626
SparqlParser$graphRef_return
100%
4/4
N/A
N/A
11,626
SparqlParser$graphTerm_return
100%
4/4
N/A
N/A
11,626
SparqlParser$groupClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$groupCondition_return
100%
4/4
N/A
N/A
11,626
SparqlParser$groupGraphPatternSubDetail_return
100%
4/4
N/A
N/A
11,626
SparqlParser$groupGraphPatternSub_return
100%
4/4
N/A
N/A
11,626
SparqlParser$groupGraphPattern_return
100%
4/4
N/A
N/A
11,626
SparqlParser$groupOrUnionGraphPattern_return
100%
4/4
N/A
N/A
11,626
SparqlParser$havingClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$insertClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$insert_return
100%
4/4
N/A
N/A
11,626
SparqlParser$iriRefOrFunction_return
100%
4/4
N/A
N/A
11,626
SparqlParser$iriRef_return
100%
4/4
N/A
N/A
11,626
SparqlParser$limitClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$limitOffsetClauses_return
100%
4/4
N/A
N/A
11,626
SparqlParser$load_return
0%
0/2
N/A
N/A
11,626
SparqlParser$minusGraphPattern_return
100%
4/4
N/A
N/A
11,626
SparqlParser$modify_return
100%
4/4
N/A
N/A
11,626
SparqlParser$move_return
0%
0/2
N/A
N/A
11,626
SparqlParser$multiplicativeExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$multiplicativeOperator_return
100%
4/4
N/A
N/A
11,626
SparqlParser$nil_return
100%
4/4
N/A
N/A
11,626
SparqlParser$notExistsFunction_return
100%
4/4
N/A
N/A
11,626
SparqlParser$numericExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$numericLiteralNegative_return
100%
4/4
N/A
N/A
11,626
SparqlParser$numericLiteralPositive_return
100%
4/4
N/A
N/A
11,626
SparqlParser$numericLiteralUnsigned_return
100%
4/4
N/A
N/A
11,626
SparqlParser$numericLiteral_return
100%
4/4
N/A
N/A
11,626
SparqlParser$objectList_return
100%
4/4
N/A
N/A
11,626
SparqlParser$offsetClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$optionalGraphPattern_return
100%
4/4
N/A
N/A
11,626
SparqlParser$orderClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$orderCondition_return
100%
4/4
N/A
N/A
11,626
SparqlParser$pathEltOrInverse_return
100%
4/4
N/A
N/A
11,626
SparqlParser$pathElt_return
100%
4/4
N/A
N/A
11,626
SparqlParser$pathMod_return
100%
4/4
N/A
N/A
11,626
SparqlParser$pathNegatedPropertySet_return
100%
4/4
N/A
N/A
11,626
SparqlParser$pathOneInPropertySet_return
100%
4/4
N/A
N/A
11,626
SparqlParser$pathPrimary_return
100%
4/4
N/A
N/A
11,626
SparqlParser$pathSequence_return
100%
4/4
N/A
N/A
11,626
SparqlParser$path_return
100%
4/4
N/A
N/A
11,626
SparqlParser$prefixDecl_return
100%
4/4
N/A
N/A
11,626
SparqlParser$prefixedName_return
100%
4/4
N/A
N/A
11,626
SparqlParser$primaryExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$prologue_return
100%
4/4
N/A
N/A
11,626
SparqlParser$propertyListNotEmptyDetails_return
100%
4/4
N/A
N/A
11,626
SparqlParser$propertyListNotEmptyPath_return
100%
4/4
N/A
N/A
11,626
SparqlParser$propertyListNotEmpty_return
100%
4/4
N/A
N/A
11,626
SparqlParser$quadPattern_return
100%
4/4
N/A
N/A
11,626
SparqlParser$quadsDetails_return
100%
4/4
N/A
N/A
11,626
SparqlParser$quadsNotTriples_return
100%
4/4
N/A
N/A
11,626
SparqlParser$quads_return
100%
4/4
N/A
N/A
11,626
SparqlParser$query_return
100%
4/4
N/A
N/A
11,626
SparqlParser$rdfLiteral_return
100%
4/4
N/A
N/A
11,626
SparqlParser$regexExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$relationalExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$selectClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$selectQuery_return
100%
4/4
N/A
N/A
11,626
SparqlParser$selectVariables_return
100%
4/4
N/A
N/A
11,626
SparqlParser$serviceGraphPattern_return
100%
4/4
N/A
N/A
11,626
SparqlParser$solutionModifier_return
100%
4/4
N/A
N/A
11,626
SparqlParser$strReplaceExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$string_return
100%
4/4
N/A
N/A
11,626
SparqlParser$subSelect_return
100%
4/4
N/A
N/A
11,626
SparqlParser$subStringExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$triplesBlock_return
100%
4/4
N/A
N/A
11,626
SparqlParser$triplesNode_return
100%
4/4
N/A
N/A
11,626
SparqlParser$triplesSameSubjectPath_return
100%
4/4
N/A
N/A
11,626
SparqlParser$triplesSameSubject_return
100%
4/4
N/A
N/A
11,626
SparqlParser$triplesTemplate_return
100%
4/4
N/A
N/A
11,626
SparqlParser$unaryExpression_return
100%
4/4
N/A
N/A
11,626
SparqlParser$update_return
100%
4/4
N/A
N/A
11,626
SparqlParser$usingClause_return
100%
4/4
N/A
N/A
11,626
SparqlParser$valueLogical_return
100%
4/4
N/A
N/A
11,626
SparqlParser$varOrIRIref_return
100%
4/4
N/A
N/A
11,626
SparqlParser$varOrTerm_return
100%
4/4
N/A
N/A
11,626
SparqlParser$var_return
100%
4/4
N/A
N/A
11,626
SparqlParser$verbPath_return
100%
4/4
N/A
N/A
11,626
SparqlParser$verbSimpleOrPath_return
100%
4/4
N/A
N/A
11,626
SparqlParser$verbSimple_return
100%
4/4
N/A
N/A
11,626
SparqlParser$verb_return
0%
0/2
N/A
N/A
11,626
SparqlParser$whereClause_return
100%
4/4
N/A
N/A
11,626
 
 1   
 // $ANTLR 3.4 com\\googlecode\\sparkleg\\Sparql.g 2012-03-17 13:43:37
 2   
 
 3   
     package com.googlecode.sparkleg;
 4   
 
 5   
 
 6   
 import org.antlr.runtime.*;
 7   
 import java.util.Stack;
 8   
 import java.util.List;
 9   
 import java.util.ArrayList;
 10   
 
 11   
 import org.antlr.runtime.tree.*;
 12   
 
 13   
 
 14   
 /**
 15   
  * @author Simone Tripodi   (simone.tripodi)
 16   
  * @author Michele Mostarda (michele.mostarda)
 17   
  * @author Juergen Pfundt   (Juergen.Pfundt)
 18   
  * @version $Id: Sparql.g 226 2011-10-22 21:13:52Z Juergen.Pfundt@gmail.com $
 19   
  */
 20   
 @SuppressWarnings({"all", "warnings", "unchecked"})
 21   
 public class SparqlParser extends Parser {
 22  7 
     public static final String[] tokenNames = new String[] {
 23   
         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "A", "ABS", "ADD", "ALL", "AND", "ANON", "ANY", "ARG_LIST", "AS", "ASC", "ASK", "ASTERISK", "AVG", "BASE", "BIND", "BINDINGS", "BINDING_VALUE", "BLANK_NODE", "BLANK_NODE_LABEL", "BNODE", "BOUND", "BRACKETTED_EXPRESSION", "BY", "CEIL", "CLEAR", "COALESCE", "COLLECTION", "COMMENT", "CONCAT", "CONSTRUCT", "CONSTRUCT_TRIPLES", "CONTAINS", "COPY", "COUNT", "CREATE", "DATA", "DATATYPE", "DAY", "DECIMAL", "DECIMAL_NEGATIVE", "DECIMAL_POSITIVE", "DEFAULT", "DELETE", "DESC", "DESCRIBE", "DIGIT", "DISTINCT", "DIVIDE", "DOT", "DOUBLE", "DOUBLE_NEGATIVE", "DOUBLE_POSITIVE", "DROP", "ECHAR", "ENCODE_FOR_URI", "EOL", "EQUAL", "EXISTS", "EXPONENT", "EXPRESSION_LIST", "FALSE", "FILTER", "FLOOR", "FROM", "FUNCTION", "GRAPH", "GREATER", "GREATER_EQUAL", "GROUP", "GROUP_BY", "GROUP_CONCAT", "GROUP_CONDITION", "GROUP_GRAPH_PATTERN", "HAVING", "HEX", "HOURS", "IF", "IN", "INSERT", "INTEGER", "INTEGER_NEGATIVE", "INTEGER_POSITIVE", "INTO", "INVERSE", "IRI", "IRI_REF", "IRI_REF_CHARACTERS", "ISBLANK", "ISIRI", "ISLITERAL", "ISNUMERIC", "ISURI", "LANG", "LANGMATCHES", "LANGTAG", "LCASE", "LESS", "LESS_EQUAL", "LIMIT", "LOAD", "MAX", "MD5", "MIN", "MINUS", "MINUS_KEYWORD", "MINUTES", "MODIFY", "MONTH", "MOVE", "NAMED", "NEGATION", "NIL", "NOT", "NOT_EQUAL", "NOT_EXISTS", "NOW", "OBJECT", "OFFSET", "OPTIONAL", "OR", "ORDER", "ORDER_BY", "ORDER_CONDITION", "PATH", "PATH_ELT_OR_INVERSE", "PATH_MOD", "PATH_NEGATED", "PATH_PRIMARY", "PATH_SEQUENCE", "PERCENT", "PLUS", "PLX", "PNAME_LN", "PNAME_NS", "PN_CHARS", "PN_CHARS_BASE", "PN_CHARS_U", "PN_LOCAL", "PN_LOCAL_ESC", "PN_PREFIX", "PREDICATE", "PREFIX", "PROLOGUE", "QUERY", "QUESTION_MARK", "RAND", "RDFLITERAL", "REDUCED", "REGEX", "REPLACE", "ROUND", "SAMETERM", "SAMPLE", "SECONDS", "SELECT", "SELECT_CLAUSE", "SEPARATOR", "SERVICE", "SHA1", "SHA224", "SHA256", "SHA384", "SHA512", "SIGN", "SILENT", "STR", "STRAFTER", "STRBEFORE", "STRDT", "STRENDS", "STRING_LITERAL1", "STRING_LITERAL2", "STRING_LITERAL_LONG1", "STRING_LITERAL_LONG2", "STRLANG", "STRLEN", "STRSTARTS", "SUBJECT", "SUBSELECT", "SUBSTR", "SUM", "TIMEZONE", "TO", "TRIPLES_BLOCK", "TRIPLES_NODE", "TRIPLES_SAME_SUBJECT", "TRIPLES_TEMPLATE", "TRUE", "TZ", "UCASE", "UNARY", "UNDEF", "UNION", "UPDATE", "URI", "USING", "VAR", "VAR1", "VAR2", "VARNAME", "WHERE", "WHERE_CLAUSE", "WITH", "WS", "YEAR", "'('", "')'", "','", "';'", "'['", "']'", "'^^'", "'{'", "'|'", "'}'"
 24   
     };
 25   
 
 26   
     public static final int EOF=-1;
 27   
     public static final int T__209=209;
 28   
     public static final int T__210=210;
 29   
     public static final int T__211=211;
 30   
     public static final int T__212=212;
 31   
     public static final int T__213=213;
 32   
     public static final int T__214=214;
 33   
     public static final int T__215=215;
 34   
     public static final int T__216=216;
 35   
     public static final int T__217=217;
 36   
     public static final int T__218=218;
 37   
     public static final int A=4;
 38   
     public static final int ABS=5;
 39   
     public static final int ADD=6;
 40   
     public static final int ALL=7;
 41   
     public static final int AND=8;
 42   
     public static final int ANON=9;
 43   
     public static final int ANY=10;
 44   
     public static final int ARG_LIST=11;
 45   
     public static final int AS=12;
 46   
     public static final int ASC=13;
 47   
     public static final int ASK=14;
 48   
     public static final int ASTERISK=15;
 49   
     public static final int AVG=16;
 50   
     public static final int BASE=17;
 51   
     public static final int BIND=18;
 52   
     public static final int BINDINGS=19;
 53   
     public static final int BINDING_VALUE=20;
 54   
     public static final int BLANK_NODE=21;
 55   
     public static final int BLANK_NODE_LABEL=22;
 56   
     public static final int BNODE=23;
 57   
     public static final int BOUND=24;
 58   
     public static final int BRACKETTED_EXPRESSION=25;
 59   
     public static final int BY=26;
 60   
     public static final int CEIL=27;
 61   
     public static final int CLEAR=28;
 62   
     public static final int COALESCE=29;
 63   
     public static final int COLLECTION=30;
 64   
     public static final int COMMENT=31;
 65   
     public static final int CONCAT=32;
 66   
     public static final int CONSTRUCT=33;
 67   
     public static final int CONSTRUCT_TRIPLES=34;
 68   
     public static final int CONTAINS=35;
 69   
     public static final int COPY=36;
 70   
     public static final int COUNT=37;
 71   
     public static final int CREATE=38;
 72   
     public static final int DATA=39;
 73   
     public static final int DATATYPE=40;
 74   
     public static final int DAY=41;
 75   
     public static final int DECIMAL=42;
 76   
     public static final int DECIMAL_NEGATIVE=43;
 77   
     public static final int DECIMAL_POSITIVE=44;
 78   
     public static final int DEFAULT=45;
 79   
     public static final int DELETE=46;
 80   
     public static final int DESC=47;
 81   
     public static final int DESCRIBE=48;
 82   
     public static final int DIGIT=49;
 83   
     public static final int DISTINCT=50;
 84   
     public static final int DIVIDE=51;
 85   
     public static final int DOT=52;
 86   
     public static final int DOUBLE=53;
 87   
     public static final int DOUBLE_NEGATIVE=54;
 88   
     public static final int DOUBLE_POSITIVE=55;
 89   
     public static final int DROP=56;
 90   
     public static final int ECHAR=57;
 91   
     public static final int ENCODE_FOR_URI=58;
 92   
     public static final int EOL=59;
 93   
     public static final int EQUAL=60;
 94   
     public static final int EXISTS=61;
 95   
     public static final int EXPONENT=62;
 96   
     public static final int EXPRESSION_LIST=63;
 97   
     public static final int FALSE=64;
 98   
     public static final int FILTER=65;
 99   
     public static final int FLOOR=66;
 100   
     public static final int FROM=67;
 101   
     public static final int FUNCTION=68;
 102   
     public static final int GRAPH=69;
 103   
     public static final int GREATER=70;
 104   
     public static final int GREATER_EQUAL=71;
 105   
     public static final int GROUP=72;
 106   
     public static final int GROUP_BY=73;
 107   
     public static final int GROUP_CONCAT=74;
 108   
     public static final int GROUP_CONDITION=75;
 109   
     public static final int GROUP_GRAPH_PATTERN=76;
 110   
     public static final int HAVING=77;
 111   
     public static final int HEX=78;
 112   
     public static final int HOURS=79;
 113   
     public static final int IF=80;
 114   
     public static final int IN=81;
 115   
     public static final int INSERT=82;
 116   
     public static final int INTEGER=83;
 117   
     public static final int INTEGER_NEGATIVE=84;
 118   
     public static final int INTEGER_POSITIVE=85;
 119   
     public static final int INTO=86;
 120   
     public static final int INVERSE=87;
 121   
     public static final int IRI=88;
 122   
     public static final int IRI_REF=89;
 123   
     public static final int IRI_REF_CHARACTERS=90;
 124   
     public static final int ISBLANK=91;
 125   
     public static final int ISIRI=92;
 126   
     public static final int ISLITERAL=93;
 127   
     public static final int ISNUMERIC=94;
 128   
     public static final int ISURI=95;
 129   
     public static final int LANG=96;
 130   
     public static final int LANGMATCHES=97;
 131   
     public static final int LANGTAG=98;
 132   
     public static final int LCASE=99;
 133   
     public static final int LESS=100;
 134   
     public static final int LESS_EQUAL=101;
 135   
     public static final int LIMIT=102;
 136   
     public static final int LOAD=103;
 137   
     public static final int MAX=104;
 138   
     public static final int MD5=105;
 139   
     public static final int MIN=106;
 140   
     public static final int MINUS=107;
 141   
     public static final int MINUS_KEYWORD=108;
 142   
     public static final int MINUTES=109;
 143   
     public static final int MODIFY=110;
 144   
     public static final int MONTH=111;
 145   
     public static final int MOVE=112;
 146   
     public static final int NAMED=113;
 147   
     public static final int NEGATION=114;
 148   
     public static final int NIL=115;
 149   
     public static final int NOT=116;
 150   
     public static final int NOT_EQUAL=117;
 151   
     public static final int NOT_EXISTS=118;
 152   
     public static final int NOW=119;
 153   
     public static final int OBJECT=120;
 154   
     public static final int OFFSET=121;
 155   
     public static final int OPTIONAL=122;
 156   
     public static final int OR=123;
 157   
     public static final int ORDER=124;
 158   
     public static final int ORDER_BY=125;
 159   
     public static final int ORDER_CONDITION=126;
 160   
     public static final int PATH=127;
 161   
     public static final int PATH_ELT_OR_INVERSE=128;
 162   
     public static final int PATH_MOD=129;
 163   
     public static final int PATH_NEGATED=130;
 164   
     public static final int PATH_PRIMARY=131;
 165   
     public static final int PATH_SEQUENCE=132;
 166   
     public static final int PERCENT=133;
 167   
     public static final int PLUS=134;
 168   
     public static final int PLX=135;
 169   
     public static final int PNAME_LN=136;
 170   
     public static final int PNAME_NS=137;
 171   
     public static final int PN_CHARS=138;
 172   
     public static final int PN_CHARS_BASE=139;
 173   
     public static final int PN_CHARS_U=140;
 174   
     public static final int PN_LOCAL=141;
 175   
     public static final int PN_LOCAL_ESC=142;
 176   
     public static final int PN_PREFIX=143;
 177   
     public static final int PREDICATE=144;
 178   
     public static final int PREFIX=145;
 179   
     public static final int PROLOGUE=146;
 180   
     public static final int QUERY=147;
 181   
     public static final int QUESTION_MARK=148;
 182   
     public static final int RAND=149;
 183   
     public static final int RDFLITERAL=150;
 184   
     public static final int REDUCED=151;
 185   
     public static final int REGEX=152;
 186   
     public static final int REPLACE=153;
 187   
     public static final int ROUND=154;
 188   
     public static final int SAMETERM=155;
 189   
     public static final int SAMPLE=156;
 190   
     public static final int SECONDS=157;
 191   
     public static final int SELECT=158;
 192   
     public static final int SELECT_CLAUSE=159;
 193   
     public static final int SEPARATOR=160;
 194   
     public static final int SERVICE=161;
 195   
     public static final int SHA1=162;
 196   
     public static final int SHA224=163;
 197   
     public static final int SHA256=164;
 198   
     public static final int SHA384=165;
 199   
     public static final int SHA512=166;
 200   
     public static final int SIGN=167;
 201   
     public static final int SILENT=168;
 202   
     public static final int STR=169;
 203   
     public static final int STRAFTER=170;
 204   
     public static final int STRBEFORE=171;
 205   
     public static final int STRDT=172;
 206   
     public static final int STRENDS=173;
 207   
     public static final int STRING_LITERAL1=174;
 208   
     public static final int STRING_LITERAL2=175;
 209   
     public static final int STRING_LITERAL_LONG1=176;
 210   
     public static final int STRING_LITERAL_LONG2=177;
 211   
     public static final int STRLANG=178;
 212   
     public static final int STRLEN=179;
 213   
     public static final int STRSTARTS=180;
 214   
     public static final int SUBJECT=181;
 215   
     public static final int SUBSELECT=182;
 216   
     public static final int SUBSTR=183;
 217   
     public static final int SUM=184;
 218   
     public static final int TIMEZONE=185;
 219   
     public static final int TO=186;
 220   
     public static final int TRIPLES_BLOCK=187;
 221   
     public static final int TRIPLES_NODE=188;
 222   
     public static final int TRIPLES_SAME_SUBJECT=189;
 223   
     public static final int TRIPLES_TEMPLATE=190;
 224   
     public static final int TRUE=191;
 225   
     public static final int TZ=192;
 226   
     public static final int UCASE=193;
 227   
     public static final int UNARY=194;
 228   
     public static final int UNDEF=195;
 229   
     public static final int UNION=196;
 230   
     public static final int UPDATE=197;
 231   
     public static final int URI=198;
 232   
     public static final int USING=199;
 233   
     public static final int VAR=200;
 234   
     public static final int VAR1=201;
 235   
     public static final int VAR2=202;
 236   
     public static final int VARNAME=203;
 237   
     public static final int WHERE=204;
 238   
     public static final int WHERE_CLAUSE=205;
 239   
     public static final int WITH=206;
 240   
     public static final int WS=207;
 241   
     public static final int YEAR=208;
 242   
 
 243   
     // delegates
 244   
     public Parser[] getDelegates() {
 245  0 
         return new Parser[] {};
 246  1958 
     }
 247  1958 
 
 248   
     // delegators
 249  1958 
 
 250  1958 
 
 251   
     public SparqlParser(TokenStream input) {
 252  9598 
         this(input, new RecognizerSharedState());
 253  7640 
     }
 254   
     public SparqlParser(TokenStream input, RecognizerSharedState state) {
 255  7640 
         super(input, state);
 256  7640 
     }
 257   
 
 258  7640 
 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 259   
 
 260  110 
 public void setTreeAdaptor(TreeAdaptor adaptor) {
 261  0 
     this.adaptor = adaptor;
 262  0 
 }
 263   
 public TreeAdaptor getTreeAdaptor() {
 264  1958 
     return adaptor;
 265   
 }
 266  1958 
     public String[] getTokenNames() { return SparqlParser.tokenNames; }
 267  0 
     public String getGrammarFileName() { return "com\\googlecode\\sparkleg\\Sparql.g"; }
 268   
 
 269   
 
 270  7640 
     public static class query_return extends ParserRuleReturnScope {
 271   
         Object tree;
 272  7640 
         public Object getTree() { return tree; }
 273  1958 
     };
 274  1958 
 
 275   
 
 276   
     // $ANTLR start "query"
 277  1958 
     // com\\googlecode\\sparkleg\\Sparql.g:98:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( ';' ( update )? )* EOF -> ^( UPDATE ( update )+ ) );
 278   
     public final SparqlParser.query_return query() throws RecognitionException {
 279  9598 
         SparqlParser.query_return retval = new SparqlParser.query_return();
 280  9598 
         retval.start = input.LT(1);
 281  1958 
 
 282  1958 
 
 283  7640 
         Object root_0 = null;
 284  1958 
 
 285  7640 
         Token EOF7=null;
 286  9598 
         Token char_literal9=null;
 287  7640 
         Token EOF11=null;
 288  9598 
         SparqlParser.prologue_return prologue1 =null;
 289   
 
 290  9598 
         SparqlParser.selectQuery_return selectQuery2 =null;
 291   
 
 292  9598 
         SparqlParser.constructQuery_return constructQuery3 =null;
 293   
 
 294  9598 
         SparqlParser.describeQuery_return describeQuery4 =null;
 295   
 
 296  9598 
         SparqlParser.askQuery_return askQuery5 =null;
 297   
 
 298  7640 
         SparqlParser.bindingsClause_return bindingsClause6 =null;
 299  1958 
 
 300  9598 
         SparqlParser.update_return update8 =null;
 301  1958 
 
 302  9598 
         SparqlParser.update_return update10 =null;
 303  1958 
 
 304  1958 
 
 305  9598 
         Object EOF7_tree=null;
 306  9598 
         Object char_literal9_tree=null;
 307  9598 
         Object EOF11_tree=null;
 308  9598 
         RewriteRuleTokenStream stream_212=new RewriteRuleTokenStream(adaptor,"token 212");
 309  9598 
         RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
 310  9598 
         RewriteRuleSubtreeStream stream_update=new RewriteRuleSubtreeStream(adaptor,"rule update");
 311  7640 
         RewriteRuleSubtreeStream stream_describeQuery=new RewriteRuleSubtreeStream(adaptor,"rule describeQuery");
 312  7640 
         RewriteRuleSubtreeStream stream_bindingsClause=new RewriteRuleSubtreeStream(adaptor,"rule bindingsClause");
 313  9598 
         RewriteRuleSubtreeStream stream_constructQuery=new RewriteRuleSubtreeStream(adaptor,"rule constructQuery");
 314  9598 
         RewriteRuleSubtreeStream stream_askQuery=new RewriteRuleSubtreeStream(adaptor,"rule askQuery");
 315  9598 
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 316  7640 
         RewriteRuleSubtreeStream stream_selectQuery=new RewriteRuleSubtreeStream(adaptor,"rule selectQuery");
 317   
         try {
 318   
             // com\\googlecode\\sparkleg\\Sparql.g:99:5: ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( ';' ( update )? )* EOF -> ^( UPDATE ( update )+ ) )
 319  9474 
             int alt4=2;
 320  9474 
             alt4 = dfa4.predict(input);
 321  7640 
             switch (alt4) {
 322  1834 
                 case 1 :
 323   
                     // com\\googlecode\\sparkleg\\Sparql.g:99:7: prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF
 324  1834 
                     {
 325  7144 
                     pushFollow(FOLLOW_prologue_in_query251);
 326  7144 
                     prologue1=prologue();
 327  1834 
 
 328  8978 
                     state._fsp--;
 329   
 
 330  7144 
                     stream_prologue.add(prologue1.getTree());
 331  1614 
 
 332   
                     // com\\googlecode\\sparkleg\\Sparql.g:99:16: ( selectQuery | constructQuery | describeQuery | askQuery )
 333  8758 
                     int alt1=4;
 334  7144 
                     switch ( input.LA(1) ) {
 335   
                     case SELECT:
 336  72 
                         {
 337  6276 
                         alt1=1;
 338  72 
                         }
 339  6276 
                         break;
 340   
                     case CONSTRUCT:
 341  28 
                         {
 342  270 
                         alt1=2;
 343  28 
                         }
 344  270 
                         break;
 345   
                     case DESCRIBE:
 346  120 
                         {
 347  112 
                         alt1=3;
 348  120 
                         }
 349  112 
                         break;
 350   
                     case ASK:
 351   
                         {
 352  486 
                         alt1=4;
 353   
                         }
 354  486 
                         break;
 355   
                     default:
 356  0 
                         NoViableAltException nvae =
 357  1834 
                             new NoViableAltException("", 1, 0, input);
 358   
 
 359  0 
                         throw nvae;
 360   
 
 361  1614 
                     }
 362  1614 
 
 363  7144 
                     switch (alt1) {
 364  1614 
                         case 1 :
 365   
                             // com\\googlecode\\sparkleg\\Sparql.g:99:17: selectQuery
 366  1614 
                             {
 367  6276 
                             pushFollow(FOLLOW_selectQuery_in_query254);
 368  6276 
                             selectQuery2=selectQuery();
 369  1614 
 
 370  6276 
                             state._fsp--;
 371   
 
 372  6276 
                             stream_selectQuery.add(selectQuery2.getTree());
 373  72 
 
 374  72 
                             }
 375  6276 
                             break;
 376  72 
                         case 2 :
 377   
                             // com\\googlecode\\sparkleg\\Sparql.g:99:31: constructQuery
 378  72 
                             {
 379  270 
                             pushFollow(FOLLOW_constructQuery_in_query258);
 380  270 
                             constructQuery3=constructQuery();
 381  72 
 
 382  270 
                             state._fsp--;
 383   
 
 384  270 
                             stream_constructQuery.add(constructQuery3.getTree());
 385  28 
 
 386  28 
                             }
 387  270 
                             break;
 388  28 
                         case 3 :
 389   
                             // com\\googlecode\\sparkleg\\Sparql.g:99:48: describeQuery
 390  28 
                             {
 391  112 
                             pushFollow(FOLLOW_describeQuery_in_query262);
 392  112 
                             describeQuery4=describeQuery();
 393  28 
 
 394  112 
                             state._fsp--;
 395   
 
 396  112 
                             stream_describeQuery.add(describeQuery4.getTree());
 397  120 
 
 398  120 
                             }
 399  112 
                             break;
 400  120 
                         case 4 :
 401   
                             // com\\googlecode\\sparkleg\\Sparql.g:99:64: askQuery
 402  120 
                             {
 403  486 
                             pushFollow(FOLLOW_askQuery_in_query266);
 404  486 
                             askQuery5=askQuery();
 405   
 
 406  486 
                             state._fsp--;
 407   
 
 408  486 
                             stream_askQuery.add(askQuery5.getTree());
 409   
 
 410  1834 
                             }
 411  1834 
                             break;
 412   
 
 413  1834 
                     }
 414   
 
 415  1834 
 
 416  7144 
                     pushFollow(FOLLOW_bindingsClause_in_query269);
 417  8978 
                     bindingsClause6=bindingsClause();
 418  1834 
 
 419  7144 
                     state._fsp--;
 420   
 
 421  7144 
                     stream_bindingsClause.add(bindingsClause6.getTree());
 422   
 
 423  7144 
                     EOF7=(Token)match(input,EOF,FOLLOW_EOF_in_query271);
 424  7144 
                     stream_EOF.add(EOF7);
 425   
 
 426   
 
 427   
                     // AST REWRITE
 428  1834 
                     // elements: selectQuery, describeQuery, constructQuery, askQuery, bindingsClause, prologue
 429  1834 
                     // token labels:
 430   
                     // rule labels: retval
 431  1834 
                     // token list labels:
 432   
                     // rule list labels:
 433   
                     // wildcard labels:
 434  7144 
                     retval.tree = root_0;
 435  7144 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 436  1834 
 
 437  8978 
                     root_0 = (Object)adaptor.nil();
 438   
                     // 99:93: -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )*
 439   
                     {
 440   
                         // com\\googlecode\\sparkleg\\Sparql.g:99:96: ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* )
 441  1834 
                         {
 442  7144 
                         Object root_1 = (Object)adaptor.nil();
 443  7144 
                         root_1 = (Object)adaptor.becomeRoot(
 444  3448 
                         (Object)adaptor.create(QUERY, "QUERY")
 445  1614 
                         , root_1);
 446   
 
 447  7144 
                         adaptor.addChild(root_1, stream_prologue.nextTree());
 448  1834 
 
 449   
                         // com\\googlecode\\sparkleg\\Sparql.g:99:113: ( selectQuery )*
 450  13420 
                         while ( stream_selectQuery.hasNext() ) {
 451  8182 
                             adaptor.addChild(root_1, stream_selectQuery.nextTree());
 452  72 
 
 453   
                         }
 454  7144 
                         stream_selectQuery.reset();
 455  1834 
 
 456   
                         // com\\googlecode\\sparkleg\\Sparql.g:99:126: ( constructQuery )*
 457  7414 
                         while ( stream_constructQuery.hasNext() ) {
 458  2132 
                             adaptor.addChild(root_1, stream_constructQuery.nextTree());
 459  28 
 
 460   
                         }
 461  7144 
                         stream_constructQuery.reset();
 462  1834 
 
 463   
                         // com\\googlecode\\sparkleg\\Sparql.g:99:142: ( describeQuery )*
 464  7256 
                         while ( stream_describeQuery.hasNext() ) {
 465  2066 
                             adaptor.addChild(root_1, stream_describeQuery.nextTree());
 466  120 
 
 467   
                         }
 468  7144 
                         stream_describeQuery.reset();
 469  1834 
 
 470   
                         // com\\googlecode\\sparkleg\\Sparql.g:99:157: ( askQuery )*
 471  9464 
                         while ( stream_askQuery.hasNext() ) {
 472  486 
                             adaptor.addChild(root_1, stream_askQuery.nextTree());
 473   
 
 474   
                         }
 475  9004 
                         stream_askQuery.reset();
 476  26 
 
 477  7144 
                         adaptor.addChild(root_0, root_1);
 478   
                         }
 479  1834 
 
 480   
                         // com\\googlecode\\sparkleg\\Sparql.g:99:168: ( bindingsClause )*
 481  7248 
                         while ( stream_bindingsClause.hasNext() ) {
 482  104 
                             adaptor.addChild(root_0, stream_bindingsClause.nextTree());
 483   
 
 484  1834 
                         }
 485  7144 
                         stream_bindingsClause.reset();
 486   
 
 487  1834 
                     }
 488   
 
 489   
 
 490  7144 
                     retval.tree = root_0;
 491  124 
 
 492  124 
                     }
 493  7144 
                     break;
 494  124 
                 case 2 :
 495   
                     // com\\googlecode\\sparkleg\\Sparql.g:100:7: update ( ';' ( update )? )* EOF
 496  124 
                     {
 497  496 
                     pushFollow(FOLLOW_update_in_query302);
 498  496 
                     update8=update();
 499   
 
 500  496 
                     state._fsp--;
 501  128 
 
 502  624 
                     stream_update.add(update8.getTree());
 503   
 
 504   
                     // com\\googlecode\\sparkleg\\Sparql.g:100:14: ( ';' ( update )? )*
 505  4 
                     loop3:
 506   
                     do {
 507  512 
                         int alt3=2;
 508  512 
                         switch ( input.LA(1) ) {
 509   
                         case 212:
 510   
                             {
 511  144 
                             alt3=1;
 512   
                             }
 513   
                             break;
 514   
 
 515  4 
                         }
 516  4 
 
 517  512 
                         switch (alt3) {
 518   
                             case 1 :
 519   
                                 // com\\googlecode\\sparkleg\\Sparql.g:100:15: ';' ( update )?
 520  4 
                                 {
 521  20 
                                 char_literal9=(Token)match(input,212,FOLLOW_212_in_query305);
 522  16 
                                 stream_212.add(char_literal9);
 523   
 
 524   
 
 525   
                                 // com\\googlecode\\sparkleg\\Sparql.g:100:19: ( update )?
 526  16 
                                 int alt2=2;
 527  16 
                                 switch ( input.LA(1) ) {
 528   
                                     case ADD:
 529   
                                     case ASK:
 530   
                                     case BASE:
 531   
                                     case CLEAR:
 532   
                                     case CONSTRUCT:
 533   
                                     case COPY:
 534   
                                     case CREATE:
 535   
                                     case DELETE:
 536   
                                     case DESCRIBE:
 537   
                                     case DROP:
 538   
                                     case INSERT:
 539  4 
                                     case LOAD:
 540   
                                     case MOVE:
 541   
                                     case PREFIX:
 542   
                                     case SELECT:
 543   
                                     case WITH:
 544  4 
                                         {
 545  16 
                                         alt2=1;
 546   
                                         }
 547   
                                         break;
 548  4 
                                 }
 549  4 
 
 550  16 
                                 switch (alt2) {
 551  4 
                                     case 1 :
 552   
                                         // com\\googlecode\\sparkleg\\Sparql.g:100:19: update
 553  4 
                                         {
 554  16 
                                         pushFollow(FOLLOW_update_in_query307);
 555  16 
                                         update10=update();
 556   
 
 557  16 
                                         state._fsp--;
 558   
 
 559  16 
                                         stream_update.add(update10.getTree());
 560   
 
 561   
                                         }
 562  4 
                                         break;
 563   
 
 564   
                                 }
 565  124 
 
 566   
 
 567  4 
                                 }
 568  16 
                                 break;
 569   
 
 570  124 
                             default :
 571  620 
                                 break loop3;
 572   
                         }
 573  16 
                     } while (true);
 574   
 
 575   
 
 576  496 
                     EOF11=(Token)match(input,EOF,FOLLOW_EOF_in_query312);
 577  496 
                     stream_EOF.add(EOF11);
 578   
 
 579   
 
 580   
                     // AST REWRITE
 581  124 
                     // elements: update
 582  124 
                     // token labels:
 583   
                     // rule labels: retval
 584  124 
                     // token list labels:
 585   
                     // rule list labels:
 586   
                     // wildcard labels:
 587  496 
                     retval.tree = root_0;
 588  496 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 589  124 
 
 590  620 
                     root_0 = (Object)adaptor.nil();
 591   
                     // 100:33: -> ^( UPDATE ( update )+ )
 592   
                     {
 593   
                         // com\\googlecode\\sparkleg\\Sparql.g:100:36: ^( UPDATE ( update )+ )
 594  124 
                         {
 595  496 
                         Object root_1 = (Object)adaptor.nil();
 596  496 
                         root_1 = (Object)adaptor.becomeRoot(
 597  252 
                         (Object)adaptor.create(UPDATE, "UPDATE")
 598  128 
                         , root_1);
 599   
 
 600  496 
                         if ( !(stream_update.hasNext()) ) {
 601  124 
                             throw new RewriteEarlyExitException();
 602   
                         }
 603  1132 
                         while ( stream_update.hasNext() ) {
 604  512 
                             adaptor.addChild(root_1, stream_update.nextTree());
 605   
 
 606   
                         }
 607  496 
                         stream_update.reset();
 608   
 
 609  620 
                         adaptor.addChild(root_0, root_1);
 610   
                         }
 611   
 
 612   
                     }
 613   
 
 614   
 
 615  2454 
                     retval.tree = root_0;
 616   
 
 617   
                     }
 618  1958 
                     break;
 619  1958 
 
 620   
             }
 621  7640 
             retval.stop = input.LT(-1);
 622   
 
 623   
 
 624  7640 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 625  7640 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 626   
 
 627   
         }
 628  0 
         catch (RecognitionException re) {
 629  0 
             reportError(re);
 630  0 
             recover(input,re);
 631  1958 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 632  1958 
 
 633   
         }
 634   
 
 635  0 
         finally {
 636   
                 // do for sure before leaving
 637  7640 
         }
 638  7640 
         return retval;
 639  1962 
     }
 640   
     // $ANTLR end "query"
 641   
 
 642   
 
 643  7656 
     public static class prologue_return extends ParserRuleReturnScope {
 644   
         Object tree;
 645  7656 
         public Object getTree() { return tree; }
 646  1962 
     };
 647  1962 
 
 648   
 
 649   
     // $ANTLR start "prologue"
 650  1962 
     // com\\googlecode\\sparkleg\\Sparql.g:103:1: prologue : ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) ;
 651   
     public final SparqlParser.prologue_return prologue() throws RecognitionException {
 652  9618 
         SparqlParser.prologue_return retval = new SparqlParser.prologue_return();
 653  7656 
         retval.start = input.LT(1);
 654  1962 
 
 655   
 
 656  7656 
         Object root_0 = null;
 657  1962 
 
 658  9618 
         SparqlParser.baseDecl_return baseDecl12 =null;
 659   
 
 660  7656 
         SparqlParser.prefixDecl_return prefixDecl13 =null;
 661   
 
 662   
 
 663  7656 
         RewriteRuleSubtreeStream stream_prefixDecl=new RewriteRuleSubtreeStream(adaptor,"rule prefixDecl");
 664  7656 
         RewriteRuleSubtreeStream stream_baseDecl=new RewriteRuleSubtreeStream(adaptor,"rule baseDecl");
 665   
         try {
 666  4814 
             // com\\googlecode\\sparkleg\\Sparql.g:105:5: ( ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) )
 667  4814 
             // com\\googlecode\\sparkleg\\Sparql.g:105:7: ( baseDecl | prefixDecl )*
 668   
             {
 669   
             // com\\googlecode\\sparkleg\\Sparql.g:105:7: ( baseDecl | prefixDecl )*
 670  62 
             loop5:
 671   
             do {
 672  19096 
                 int alt5=3;
 673  19034 
                 switch ( input.LA(1) ) {
 674   
                 case BASE:
 675  2790 
                     {
 676  248 
                     alt5=1;
 677   
                     }
 678  248 
                     break;
 679   
                 case PREFIX:
 680   
                     {
 681  15944 
                     alt5=2;
 682   
                     }
 683   
                     break;
 684   
 
 685  62 
                 }
 686  62 
 
 687  19034 
                 switch (alt5) {
 688  62 
                     case 1 :
 689   
                         // com\\googlecode\\sparkleg\\Sparql.g:105:8: baseDecl
 690  62 
                         {
 691  248 
                         pushFollow(FOLLOW_baseDecl_in_prologue345);
 692  248 
                         baseDecl12=baseDecl();
 693  62 
 
 694  248 
                         state._fsp--;
 695   
 
 696  248 
                         stream_baseDecl.add(baseDecl12.getTree());
 697  2790 
 
 698  2790 
                         }
 699  248 
                         break;
 700  2790 
                     case 2 :
 701   
                         // com\\googlecode\\sparkleg\\Sparql.g:105:19: prefixDecl
 702  2790 
                         {
 703  11130 
                         pushFollow(FOLLOW_prefixDecl_in_prologue349);
 704  11130 
                         prefixDecl13=prefixDecl();
 705  2790 
 
 706  11130 
                         state._fsp--;
 707   
 
 708  13092 
                         stream_prefixDecl.add(prefixDecl13.getTree());
 709   
 
 710  2852 
                         }
 711  11130 
                         break;
 712   
 
 713   
                     default :
 714  7656 
                         break loop5;
 715   
                 }
 716  11378 
             } while (true);
 717   
 
 718   
 
 719   
             // AST REWRITE
 720  1962 
             // elements: baseDecl, prefixDecl
 721  1962 
             // token labels:
 722   
             // rule labels: retval
 723  1962 
             // token list labels:
 724   
             // rule list labels:
 725   
             // wildcard labels:
 726  7656 
             retval.tree = root_0;
 727  7656 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 728  1962 
 
 729  9618 
             root_0 = (Object)adaptor.nil();
 730   
             // 105:32: -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 731   
             {
 732   
                 // com\\googlecode\\sparkleg\\Sparql.g:105:35: ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 733   
                 {
 734  9680 
                 Object root_1 = (Object)adaptor.nil();
 735  7718 
                 root_1 = (Object)adaptor.becomeRoot(
 736   
                 (Object)adaptor.create(PROLOGUE, "PROLOGUE")
 737   
                 , root_1);
 738  1962 
 
 739   
                 // com\\googlecode\\sparkleg\\Sparql.g:105:46: ( baseDecl )*
 740  7904 
                 while ( stream_baseDecl.hasNext() ) {
 741  5000 
                     adaptor.addChild(root_1, stream_baseDecl.nextTree());
 742  2790 
 
 743   
                 }
 744  7656 
                 stream_baseDecl.reset();
 745  1962 
 
 746   
                 // com\\googlecode\\sparkleg\\Sparql.g:105:56: ( prefixDecl )*
 747  20748 
                 while ( stream_prefixDecl.hasNext() ) {
 748  11130 
                     adaptor.addChild(root_1, stream_prefixDecl.nextTree());
 749   
 
 750   
                 }
 751  7656 
                 stream_prefixDecl.reset();
 752   
 
 753  9618 
                 adaptor.addChild(root_0, root_1);
 754   
                 }
 755   
 
 756   
             }
 757  1962 
 
 758   
 
 759  7656 
             retval.tree = root_0;
 760  1962 
 
 761  1962 
             }
 762   
 
 763  7656 
             retval.stop = input.LT(-1);
 764   
 
 765   
 
 766  7656 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 767  7656 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 768   
 
 769   
         }
 770  0 
         catch (RecognitionException re) {
 771  0 
             reportError(re);
 772  0 
             recover(input,re);
 773  1962 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 774  1962 
 
 775   
         }
 776   
 
 777  0 
         finally {
 778   
                 // do for sure before leaving
 779  62 
         }
 780  7656 
         return retval;
 781  62 
     }
 782   
     // $ANTLR end "prologue"
 783   
 
 784   
 
 785  248 
     public static class baseDecl_return extends ParserRuleReturnScope {
 786   
         Object tree;
 787  248 
         public Object getTree() { return tree; }
 788  62 
     };
 789  62 
 
 790   
 
 791   
     // $ANTLR start "baseDecl"
 792  62 
     // com\\googlecode\\sparkleg\\Sparql.g:108:1: baseDecl : BASE IRI_REF -> ^( BASE IRI_REF ) ;
 793   
     public final SparqlParser.baseDecl_return baseDecl() throws RecognitionException {
 794  310 
         SparqlParser.baseDecl_return retval = new SparqlParser.baseDecl_return();
 795  310 
         retval.start = input.LT(1);
 796   
 
 797  62 
 
 798  310 
         Object root_0 = null;
 799  62 
 
 800  310 
         Token BASE14=null;
 801  248 
         Token IRI_REF15=null;
 802   
 
 803  248 
         Object BASE14_tree=null;
 804  248 
         Object IRI_REF15_tree=null;
 805  248 
         RewriteRuleTokenStream stream_BASE=new RewriteRuleTokenStream(adaptor,"token BASE");
 806  310 
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 807  62 
 
 808   
         try {
 809   
             // com\\googlecode\\sparkleg\\Sparql.g:109:5: ( BASE IRI_REF -> ^( BASE IRI_REF ) )
 810  62 
             // com\\googlecode\\sparkleg\\Sparql.g:109:7: BASE IRI_REF
 811  62 
             {
 812  248 
             BASE14=(Token)match(input,BASE,FOLLOW_BASE_in_baseDecl380);
 813  248 
             stream_BASE.add(BASE14);
 814   
 
 815   
 
 816  248 
             IRI_REF15=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_baseDecl382);
 817  248 
             stream_IRI_REF.add(IRI_REF15);
 818   
 
 819   
 
 820   
             // AST REWRITE
 821  62 
             // elements: IRI_REF, BASE
 822  62 
             // token labels:
 823   
             // rule labels: retval
 824  62 
             // token list labels:
 825   
             // rule list labels:
 826   
             // wildcard labels:
 827  248 
             retval.tree = root_0;
 828  248 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 829  62 
 
 830  310 
             root_0 = (Object)adaptor.nil();
 831   
             // 109:20: -> ^( BASE IRI_REF )
 832   
             {
 833   
                 // com\\googlecode\\sparkleg\\Sparql.g:109:23: ^( BASE IRI_REF )
 834  62 
                 {
 835  248 
                 Object root_1 = (Object)adaptor.nil();
 836  248 
                 root_1 = (Object)adaptor.becomeRoot(
 837   
                 stream_BASE.nextNode()
 838  62 
                 , root_1);
 839   
 
 840  248 
                 adaptor.addChild(root_1,
 841   
                 stream_IRI_REF.nextNode()
 842   
                 );
 843   
 
 844  310 
                 adaptor.addChild(root_0, root_1);
 845   
                 }
 846   
 
 847   
             }
 848  62 
 
 849   
 
 850  248 
             retval.tree = root_0;
 851  62 
 
 852  62 
             }
 853   
 
 854  248 
             retval.stop = input.LT(-1);
 855   
 
 856   
 
 857  248 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 858  248 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 859   
 
 860   
         }
 861  0 
         catch (RecognitionException re) {
 862  0 
             reportError(re);
 863  0 
             recover(input,re);
 864  62 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 865  62 
 
 866   
         }
 867   
 
 868  0 
         finally {
 869   
                 // do for sure before leaving
 870  248 
         }
 871  248 
         return retval;
 872  2790 
     }
 873   
     // $ANTLR end "baseDecl"
 874   
 
 875   
 
 876  11130 
     public static class prefixDecl_return extends ParserRuleReturnScope {
 877   
         Object tree;
 878  11130 
         public Object getTree() { return tree; }
 879  2790 
     };
 880  2790 
 
 881   
 
 882   
     // $ANTLR start "prefixDecl"
 883  2790 
     // com\\googlecode\\sparkleg\\Sparql.g:112:1: prefixDecl : PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) ;
 884   
     public final SparqlParser.prefixDecl_return prefixDecl() throws RecognitionException {
 885  13920 
         SparqlParser.prefixDecl_return retval = new SparqlParser.prefixDecl_return();
 886  13920 
         retval.start = input.LT(1);
 887  2790 
 
 888   
 
 889  13920 
         Object root_0 = null;
 890  2790 
 
 891  13920 
         Token PREFIX16=null;
 892  13920 
         Token PNAME_NS17=null;
 893  13920 
         Token IRI_REF18=null;
 894  2790 
 
 895  11130 
         Object PREFIX16_tree=null;
 896  11130 
         Object PNAME_NS17_tree=null;
 897  11130 
         Object IRI_REF18_tree=null;
 898  11130 
         RewriteRuleTokenStream stream_PREFIX=new RewriteRuleTokenStream(adaptor,"token PREFIX");
 899  11130 
         RewriteRuleTokenStream stream_PNAME_NS=new RewriteRuleTokenStream(adaptor,"token PNAME_NS");
 900  13920 
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 901  2790 
 
 902   
         try {
 903   
             // com\\googlecode\\sparkleg\\Sparql.g:113:5: ( PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) )
 904  2790 
             // com\\googlecode\\sparkleg\\Sparql.g:113:7: PREFIX PNAME_NS IRI_REF
 905  2790 
             {
 906  11130 
             PREFIX16=(Token)match(input,PREFIX,FOLLOW_PREFIX_in_prefixDecl408);
 907  11130 
             stream_PREFIX.add(PREFIX16);
 908  2790 
 
 909  2790 
 
 910  11130 
             PNAME_NS17=(Token)match(input,PNAME_NS,FOLLOW_PNAME_NS_in_prefixDecl410);
 911  11130 
             stream_PNAME_NS.add(PNAME_NS17);
 912   
 
 913   
 
 914  11130 
             IRI_REF18=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_prefixDecl412);
 915  11130 
             stream_IRI_REF.add(IRI_REF18);
 916   
 
 917   
 
 918   
             // AST REWRITE
 919  2790 
             // elements: PNAME_NS, IRI_REF, PREFIX
 920  2790 
             // token labels:
 921   
             // rule labels: retval
 922  2790 
             // token list labels:
 923   
             // rule list labels:
 924   
             // wildcard labels:
 925  11130 
             retval.tree = root_0;
 926  11130 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 927  2790 
 
 928  13920 
             root_0 = (Object)adaptor.nil();
 929   
             // 113:31: -> ^( PREFIX PNAME_NS IRI_REF )
 930   
             {
 931   
                 // com\\googlecode\\sparkleg\\Sparql.g:113:34: ^( PREFIX PNAME_NS IRI_REF )
 932  2790 
                 {
 933  11130 
                 Object root_1 = (Object)adaptor.nil();
 934  11130 
                 root_1 = (Object)adaptor.becomeRoot(
 935   
                 stream_PREFIX.nextNode()
 936  2790 
                 , root_1);
 937   
 
 938  11130 
                 adaptor.addChild(root_1,
 939   
                 stream_PNAME_NS.nextNode()
 940  2790 
                 );
 941   
 
 942  11130 
                 adaptor.addChild(root_1,
 943   
                 stream_IRI_REF.nextNode()
 944   
                 );
 945   
 
 946  13920 
                 adaptor.addChild(root_0, root_1);
 947   
                 }
 948   
 
 949   
             }
 950  2790 
 
 951   
 
 952  11130 
             retval.tree = root_0;
 953  2790 
 
 954  2790 
             }
 955   
 
 956  11130 
             retval.stop = input.LT(-1);
 957   
 
 958   
 
 959  11130 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 960  11130 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 961   
 
 962   
         }
 963  0 
         catch (RecognitionException re) {
 964  0 
             reportError(re);
 965  0 
             recover(input,re);
 966  2790 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 967  2790 
 
 968   
         }
 969   
 
 970  0 
         finally {
 971   
                 // do for sure before leaving
 972  11130 
         }
 973  11130 
         return retval;
 974  1614 
     }
 975   
     // $ANTLR end "prefixDecl"
 976   
 
 977   
 
 978  6276 
     public static class selectQuery_return extends ParserRuleReturnScope {
 979   
         Object tree;
 980  6276 
         public Object getTree() { return tree; }
 981  1614 
     };
 982  1614 
 
 983   
 
 984   
     // $ANTLR start "selectQuery"
 985  1614 
     // com\\googlecode\\sparkleg\\Sparql.g:116:1: selectQuery : selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) ;
 986   
     public final SparqlParser.selectQuery_return selectQuery() throws RecognitionException {
 987  7890 
         SparqlParser.selectQuery_return retval = new SparqlParser.selectQuery_return();
 988  6276 
         retval.start = input.LT(1);
 989  1614 
 
 990   
 
 991  7890 
         Object root_0 = null;
 992   
 
 993  7890 
         SparqlParser.selectClause_return selectClause19 =null;
 994   
 
 995  6276 
         SparqlParser.datasetClause_return datasetClause20 =null;
 996  1614 
 
 997  7890 
         SparqlParser.whereClause_return whereClause21 =null;
 998  1614 
 
 999  7890 
         SparqlParser.solutionModifier_return solutionModifier22 =null;
 1000   
 
 1001   
 
 1002  6276 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1003  6276 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 1004  7890 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1005  7890 
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 1006   
         try {
 1007  1614 
             // com\\googlecode\\sparkleg\\Sparql.g:117:5: ( selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) )
 1008   
             // com\\googlecode\\sparkleg\\Sparql.g:117:7: selectClause ( datasetClause )* whereClause solutionModifier
 1009  1614 
             {
 1010  6276 
             pushFollow(FOLLOW_selectClause_in_selectQuery439);
 1011  6276 
             selectClause19=selectClause();
 1012   
 
 1013  6276 
             state._fsp--;
 1014  1772 
 
 1015  8048 
             stream_selectClause.add(selectClause19.getTree());
 1016   
 
 1017   
             // com\\googlecode\\sparkleg\\Sparql.g:117:20: ( datasetClause )*
 1018  158 
             loop6:
 1019   
             do {
 1020  6908 
                 int alt6=2;
 1021  6908 
                 switch ( input.LA(1) ) {
 1022   
                 case FROM:
 1023   
                     {
 1024  2404 
                     alt6=1;
 1025   
                     }
 1026   
                     break;
 1027   
 
 1028  158 
                 }
 1029  158 
 
 1030  6908 
                 switch (alt6) {
 1031  158 
                     case 1 :
 1032   
                         // com\\googlecode\\sparkleg\\Sparql.g:117:20: datasetClause
 1033  158 
                         {
 1034  632 
                         pushFollow(FOLLOW_datasetClause_in_selectQuery441);
 1035  632 
                         datasetClause20=datasetClause();
 1036  158 
 
 1037  632 
                         state._fsp--;
 1038   
 
 1039  2246 
                         stream_datasetClause.add(datasetClause20.getTree());
 1040   
 
 1041  158 
                         }
 1042  632 
                         break;
 1043   
 
 1044  1614 
                     default :
 1045  7890 
                         break loop6;
 1046   
                 }
 1047  2246 
             } while (true);
 1048   
 
 1049  1614 
 
 1050  6276 
             pushFollow(FOLLOW_whereClause_in_selectQuery444);
 1051  7890 
             whereClause21=whereClause();
 1052  1614 
 
 1053  6276 
             state._fsp--;
 1054  1614 
 
 1055  6276 
             stream_whereClause.add(whereClause21.getTree());
 1056  1614 
 
 1057  6276 
             pushFollow(FOLLOW_solutionModifier_in_selectQuery446);
 1058  6276 
             solutionModifier22=solutionModifier();
 1059   
 
 1060  6276 
             state._fsp--;
 1061   
 
 1062  6276 
             stream_solutionModifier.add(solutionModifier22.getTree());
 1063   
 
 1064   
             // AST REWRITE
 1065  1614 
             // elements: datasetClause, selectClause, solutionModifier, whereClause
 1066  1614 
             // token labels:
 1067   
             // rule labels: retval
 1068  1614 
             // token list labels:
 1069   
             // rule list labels:
 1070   
             // wildcard labels:
 1071  6276 
             retval.tree = root_0;
 1072  6276 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1073  1614 
 
 1074  7890 
             root_0 = (Object)adaptor.nil();
 1075   
             // 117:64: -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1076   
             {
 1077   
                 // com\\googlecode\\sparkleg\\Sparql.g:117:67: ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1078  1614 
                 {
 1079  6276 
                 Object root_1 = (Object)adaptor.nil();
 1080  6276 
                 root_1 = (Object)adaptor.becomeRoot(
 1081  1772 
                 (Object)adaptor.create(SELECT, "SELECT")
 1082  158 
                 , root_1);
 1083   
 
 1084  6276 
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1085  1614 
 
 1086   
                 // com\\googlecode\\sparkleg\\Sparql.g:117:89: ( datasetClause )*
 1087  6908 
                 while ( stream_datasetClause.hasNext() ) {
 1088  3860 
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1089  1614 
 
 1090   
                 }
 1091  6276 
                 stream_datasetClause.reset();
 1092  1614 
 
 1093   
                 // com\\googlecode\\sparkleg\\Sparql.g:117:104: ( whereClause )*
 1094  12552 
                 while ( stream_whereClause.hasNext() ) {
 1095  8078 
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1096  188 
 
 1097   
                 }
 1098  6276 
                 stream_whereClause.reset();
 1099  1614 
 
 1100   
                 // com\\googlecode\\sparkleg\\Sparql.g:117:117: ( solutionModifier )*
 1101  8642 
                 while ( stream_solutionModifier.hasNext() ) {
 1102  752 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1103   
 
 1104   
                 }
 1105  6276 
                 stream_solutionModifier.reset();
 1106   
 
 1107  7890 
                 adaptor.addChild(root_0, root_1);
 1108   
                 }
 1109   
 
 1110   
             }
 1111  1614 
 
 1112   
 
 1113  6276 
             retval.tree = root_0;
 1114  1614 
 
 1115  1614 
             }
 1116   
 
 1117  6276 
             retval.stop = input.LT(-1);
 1118   
 
 1119   
 
 1120  6276 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1121  6276 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1122   
 
 1123   
         }
 1124  0 
         catch (RecognitionException re) {
 1125  0 
             reportError(re);
 1126  0 
             recover(input,re);
 1127  1614 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1128  1614 
 
 1129   
         }
 1130   
 
 1131  0 
         finally {
 1132   
                 // do for sure before leaving
 1133  46 
         }
 1134  6276 
         return retval;
 1135  46 
     }
 1136   
     // $ANTLR end "selectQuery"
 1137   
 
 1138   
 
 1139  184 
     public static class subSelect_return extends ParserRuleReturnScope {
 1140   
         Object tree;
 1141  184 
         public Object getTree() { return tree; }
 1142  46 
     };
 1143  46 
 
 1144   
 
 1145   
     // $ANTLR start "subSelect"
 1146  46 
     // com\\googlecode\\sparkleg\\Sparql.g:120:1: subSelect : selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) ;
 1147   
     public final SparqlParser.subSelect_return subSelect() throws RecognitionException {
 1148  230 
         SparqlParser.subSelect_return retval = new SparqlParser.subSelect_return();
 1149  184 
         retval.start = input.LT(1);
 1150  46 
 
 1151   
 
 1152  230 
         Object root_0 = null;
 1153   
 
 1154  184 
         SparqlParser.selectClause_return selectClause23 =null;
 1155  46 
 
 1156  230 
         SparqlParser.whereClause_return whereClause24 =null;
 1157  46 
 
 1158  184 
         SparqlParser.solutionModifier_return solutionModifier25 =null;
 1159   
 
 1160   
 
 1161  184 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1162  230 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1163  230 
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 1164   
         try {
 1165  46 
             // com\\googlecode\\sparkleg\\Sparql.g:121:5: ( selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) )
 1166   
             // com\\googlecode\\sparkleg\\Sparql.g:121:7: selectClause whereClause solutionModifier
 1167  46 
             {
 1168  184 
             pushFollow(FOLLOW_selectClause_in_subSelect480);
 1169  230 
             selectClause23=selectClause();
 1170  46 
 
 1171  184 
             state._fsp--;
 1172  46 
 
 1173  184 
             stream_selectClause.add(selectClause23.getTree());
 1174  46 
 
 1175  184 
             pushFollow(FOLLOW_whereClause_in_subSelect482);
 1176  230 
             whereClause24=whereClause();
 1177  46 
 
 1178  184 
             state._fsp--;
 1179  46 
 
 1180  184 
             stream_whereClause.add(whereClause24.getTree());
 1181  46 
 
 1182  184 
             pushFollow(FOLLOW_solutionModifier_in_subSelect484);
 1183  184 
             solutionModifier25=solutionModifier();
 1184   
 
 1185  184 
             state._fsp--;
 1186   
 
 1187  184 
             stream_solutionModifier.add(solutionModifier25.getTree());
 1188   
 
 1189   
             // AST REWRITE
 1190  46 
             // elements: whereClause, selectClause, solutionModifier
 1191  46 
             // token labels:
 1192   
             // rule labels: retval
 1193  46 
             // token list labels:
 1194   
             // rule list labels:
 1195   
             // wildcard labels:
 1196  184 
             retval.tree = root_0;
 1197  184 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1198  46 
 
 1199  230 
             root_0 = (Object)adaptor.nil();
 1200   
             // 121:49: -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1201   
             {
 1202   
                 // com\\googlecode\\sparkleg\\Sparql.g:121:52: ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1203  46 
                 {
 1204  184 
                 Object root_1 = (Object)adaptor.nil();
 1205  184 
                 root_1 = (Object)adaptor.becomeRoot(
 1206  92 
                 (Object)adaptor.create(SUBSELECT, "SUBSELECT")
 1207  46 
                 , root_1);
 1208   
 
 1209  184 
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1210  46 
 
 1211   
                 // com\\googlecode\\sparkleg\\Sparql.g:121:77: ( whereClause )*
 1212  368 
                 while ( stream_whereClause.hasNext() ) {
 1213  240 
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1214  10 
 
 1215   
                 }
 1216  184 
                 stream_whereClause.reset();
 1217  46 
 
 1218   
                 // com\\googlecode\\sparkleg\\Sparql.g:121:90: ( solutionModifier )*
 1219  270 
                 while ( stream_solutionModifier.hasNext() ) {
 1220  40 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1221   
 
 1222   
                 }
 1223  184 
                 stream_solutionModifier.reset();
 1224   
 
 1225  230 
                 adaptor.addChild(root_0, root_1);
 1226   
                 }
 1227   
 
 1228   
             }
 1229  46 
 
 1230   
 
 1231  184 
             retval.tree = root_0;
 1232  46 
 
 1233  46 
             }
 1234   
 
 1235  184 
             retval.stop = input.LT(-1);
 1236   
 
 1237   
 
 1238  184 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1239  184 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1240   
 
 1241   
         }
 1242  0 
         catch (RecognitionException re) {
 1243  0 
             reportError(re);
 1244  0 
             recover(input,re);
 1245  46 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1246  46 
 
 1247   
         }
 1248   
 
 1249  0 
         finally {
 1250   
                 // do for sure before leaving
 1251  184 
         }
 1252  184 
         return retval;
 1253  1660 
     }
 1254   
     // $ANTLR end "subSelect"
 1255   
 
 1256   
 
 1257  6460 
     public static class selectClause_return extends ParserRuleReturnScope {
 1258   
         Object tree;
 1259  6460 
         public Object getTree() { return tree; }
 1260  1660 
     };
 1261  1660 
 
 1262   
 
 1263   
     // $ANTLR start "selectClause"
 1264  1660 
     // com\\googlecode\\sparkleg\\Sparql.g:124:1: selectClause : ( SELECT ( DISTINCT | REDUCED )? '*' -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* '*' ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) );
 1265   
     public final SparqlParser.selectClause_return selectClause() throws RecognitionException {
 1266  8120 
         SparqlParser.selectClause_return retval = new SparqlParser.selectClause_return();
 1267  8120 
         retval.start = input.LT(1);
 1268  1660 
 
 1269  1660 
 
 1270  8120 
         Object root_0 = null;
 1271  1660 
 
 1272  8120 
         Token SELECT26=null;
 1273  8120 
         Token DISTINCT27=null;
 1274  8120 
         Token REDUCED28=null;
 1275  8120 
         Token char_literal29=null;
 1276  8120 
         Token SELECT30=null;
 1277  8120 
         Token DISTINCT31=null;
 1278  8120 
         Token REDUCED32=null;
 1279  8120 
         List list_v=null;
 1280  8120 
         RuleReturnScope v = null;
 1281  8120 
         Object SELECT26_tree=null;
 1282  8120 
         Object DISTINCT27_tree=null;
 1283  8120 
         Object REDUCED28_tree=null;
 1284  8120 
         Object char_literal29_tree=null;
 1285  8120 
         Object SELECT30_tree=null;
 1286  8120 
         Object DISTINCT31_tree=null;
 1287  6460 
         Object REDUCED32_tree=null;
 1288  6460 
         RewriteRuleTokenStream stream_SELECT=new RewriteRuleTokenStream(adaptor,"token SELECT");
 1289  8120 
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 1290  8120 
         RewriteRuleTokenStream stream_REDUCED=new RewriteRuleTokenStream(adaptor,"token REDUCED");
 1291  6460 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 1292  6460 
         RewriteRuleSubtreeStream stream_selectVariables=new RewriteRuleSubtreeStream(adaptor,"rule selectVariables");
 1293  1660 
         try {
 1294   
             // com\\googlecode\\sparkleg\\Sparql.g:125:5: ( SELECT ( DISTINCT | REDUCED )? '*' -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* '*' ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) )
 1295  6460 
             int alt10=2;
 1296  6504 
             switch ( input.LA(1) ) {
 1297   
             case SELECT:
 1298   
                 {
 1299  6462 
                 switch ( input.LA(2) ) {
 1300   
                 case DISTINCT:
 1301  2 
                     {
 1302  176 
                     switch ( input.LA(3) ) {
 1303   
                     case ASTERISK:
 1304   
                         {
 1305  8 
                         alt10=1;
 1306  42 
                         }
 1307  8 
                         break;
 1308  42 
                     case VAR1:
 1309   
                     case VAR2:
 1310   
                     case 209:
 1311   
                         {
 1312  168 
                         alt10=2;
 1313   
                         }
 1314  168 
                         break;
 1315   
                     default:
 1316  0 
                         NoViableAltException nvae =
 1317   
                             new NoViableAltException("", 10, 2, input);
 1318  44 
 
 1319  0 
                         throw nvae;
 1320   
 
 1321  14 
                     }
 1322   
 
 1323   
                     }
 1324  180 
                     break;
 1325   
                 case REDUCED:
 1326  4 
                     {
 1327  56 
                     switch ( input.LA(3) ) {
 1328   
                     case ASTERISK:
 1329   
                         {
 1330  16 
                         alt10=1;
 1331  10 
                         }
 1332  16 
                         break;
 1333  10 
                     case VAR1:
 1334   
                     case VAR2:
 1335   
                     case 209:
 1336   
                         {
 1337  40 
                         alt10=2;
 1338   
                         }
 1339  40 
                         break;
 1340   
                     default:
 1341  0 
                         NoViableAltException nvae =
 1342   
                             new NoViableAltException("", 10, 3, input);
 1343  14 
 
 1344  0 
                         throw nvae;
 1345   
 
 1346  680 
                     }
 1347   
 
 1348  680 
                     }
 1349  56 
                     break;
 1350   
                 case ASTERISK:
 1351   
                     {
 1352  2516 
                     alt10=1;
 1353  922 
                     }
 1354  2516 
                     break;
 1355  922 
                 case VAR1:
 1356   
                 case VAR2:
 1357   
                 case 209:
 1358   
                     {
 1359  3712 
                     alt10=2;
 1360   
                     }
 1361  3712 
                     break;
 1362   
                 default:
 1363  0 
                     NoViableAltException nvae =
 1364   
                         new NoViableAltException("", 10, 1, input);
 1365  1660 
 
 1366  0 
                     throw nvae;
 1367   
 
 1368   
                 }
 1369   
 
 1370   
                 }
 1371  6460 
                 break;
 1372   
             default:
 1373  0 
                 NoViableAltException nvae =
 1374  1660 
                     new NoViableAltException("", 10, 0, input);
 1375   
 
 1376  0 
                 throw nvae;
 1377   
 
 1378  686 
             }
 1379  686 
 
 1380  6460 
             switch (alt10) {
 1381   
                 case 1 :
 1382   
                     // com\\googlecode\\sparkleg\\Sparql.g:125:7: SELECT ( DISTINCT | REDUCED )? '*'
 1383  686 
                     {
 1384  3226 
                     SELECT26=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause520);
 1385  2540 
                     stream_SELECT.add(SELECT26);
 1386   
 
 1387  2 
 
 1388   
                     // com\\googlecode\\sparkleg\\Sparql.g:125:14: ( DISTINCT | REDUCED )?
 1389  2542 
                     int alt7=3;
 1390  2540 
                     switch ( input.LA(1) ) {
 1391   
                         case DISTINCT:
 1392  4 
                             {
 1393  8 
                             alt7=1;
 1394   
                             }
 1395  8 
                             break;
 1396   
                         case REDUCED:
 1397  686 
                             {
 1398  16 
                             alt7=2;
 1399   
                             }
 1400   
                             break;
 1401  2 
                     }
 1402  2 
 
 1403  2540 
                     switch (alt7) {
 1404   
                         case 1 :
 1405   
                             // com\\googlecode\\sparkleg\\Sparql.g:125:15: DISTINCT
 1406  2 
                             {
 1407  8 
                             DISTINCT27=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause523);
 1408  8 
                             stream_DISTINCT.add(DISTINCT27);
 1409   
 
 1410  4 
 
 1411  4 
                             }
 1412  8 
                             break;
 1413   
                         case 2 :
 1414   
                             // com\\googlecode\\sparkleg\\Sparql.g:125:26: REDUCED
 1415   
                             {
 1416  16 
                             REDUCED28=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause527);
 1417  16 
                             stream_REDUCED.add(REDUCED28);
 1418   
 
 1419   
 
 1420  686 
                             }
 1421  686 
                             break;
 1422   
 
 1423   
                     }
 1424   
 
 1425   
 
 1426  2540 
                     char_literal29=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_selectClause531);
 1427  2540 
                     stream_ASTERISK.add(char_literal29);
 1428   
 
 1429   
 
 1430   
                     // AST REWRITE
 1431  686 
                     // elements: DISTINCT, REDUCED, ASTERISK
 1432  686 
                     // token labels:
 1433   
                     // rule labels: retval
 1434  686 
                     // token list labels:
 1435   
                     // rule list labels:
 1436   
                     // wildcard labels:
 1437  2540 
                     retval.tree = root_0;
 1438  2540 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1439  686 
 
 1440  3226 
                     root_0 = (Object)adaptor.nil();
 1441   
                     // 125:40: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* '*' )
 1442   
                     {
 1443   
                         // com\\googlecode\\sparkleg\\Sparql.g:125:43: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* '*' )
 1444   
                         {
 1445  3228 
                         Object root_1 = (Object)adaptor.nil();
 1446  2542 
                         root_1 = (Object)adaptor.becomeRoot(
 1447   
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1448   
                         , root_1);
 1449   
 
 1450   
                         // com\\googlecode\\sparkleg\\Sparql.g:125:59: ( DISTINCT )*
 1451  3234 
                         while ( stream_DISTINCT.hasNext() ) {
 1452  8 
                             adaptor.addChild(root_1,
 1453   
                             stream_DISTINCT.nextNode()
 1454  690 
                             );
 1455  4 
 
 1456   
                         }
 1457  2540 
                         stream_DISTINCT.reset();
 1458   
 
 1459   
                         // com\\googlecode\\sparkleg\\Sparql.g:125:69: ( REDUCED )*
 1460  3242 
                         while ( stream_REDUCED.hasNext() ) {
 1461  16 
                             adaptor.addChild(root_1,
 1462  686 
                             stream_REDUCED.nextNode()
 1463   
                             );
 1464   
 
 1465   
                         }
 1466  3226 
                         stream_REDUCED.reset();
 1467   
 
 1468  2540 
                         adaptor.addChild(root_1,
 1469   
                         stream_ASTERISK.nextNode()
 1470   
                         );
 1471   
 
 1472  3226 
                         adaptor.addChild(root_0, root_1);
 1473   
                         }
 1474   
 
 1475  686 
                     }
 1476   
 
 1477   
 
 1478  2540 
                     retval.tree = root_0;
 1479  974 
 
 1480  974 
                     }
 1481  2540 
                     break;
 1482   
                 case 2 :
 1483   
                     // com\\googlecode\\sparkleg\\Sparql.g:126:7: SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+
 1484  974 
                     {
 1485  4894 
                     SELECT30=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause553);
 1486  3920 
                     stream_SELECT.add(SELECT30);
 1487   
 
 1488  42 
 
 1489   
                     // com\\googlecode\\sparkleg\\Sparql.g:126:14: ( DISTINCT | REDUCED )?
 1490  3962 
                     int alt8=3;
 1491  3920 
                     switch ( input.LA(1) ) {
 1492   
                         case DISTINCT:
 1493  10 
                             {
 1494  168 
                             alt8=1;
 1495   
                             }
 1496  168 
                             break;
 1497   
                         case REDUCED:
 1498  974 
                             {
 1499  40 
                             alt8=2;
 1500   
                             }
 1501   
                             break;
 1502  42 
                     }
 1503  42 
 
 1504  3920 
                     switch (alt8) {
 1505   
                         case 1 :
 1506   
                             // com\\googlecode\\sparkleg\\Sparql.g:126:15: DISTINCT
 1507  42 
                             {
 1508  168 
                             DISTINCT31=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause556);
 1509  168 
                             stream_DISTINCT.add(DISTINCT31);
 1510   
 
 1511  10 
 
 1512  10 
                             }
 1513  168 
                             break;
 1514   
                         case 2 :
 1515   
                             // com\\googlecode\\sparkleg\\Sparql.g:126:26: REDUCED
 1516   
                             {
 1517  40 
                             REDUCED32=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause560);
 1518  40 
                             stream_REDUCED.add(REDUCED32);
 1519   
 
 1520   
 
 1521   
                             }
 1522  974 
                             break;
 1523   
 
 1524   
                     }
 1525  2630 
 
 1526  2630 
 
 1527   
                     // com\\googlecode\\sparkleg\\Sparql.g:126:36: (v+= selectVariables )+
 1528  3920 
                     int cnt9=0;
 1529   
                     loop9:
 1530   
                     do {
 1531  12230 
                         int alt9=2;
 1532  10574 
                         switch ( input.LA(1) ) {
 1533   
                         case VAR1:
 1534   
                         case VAR2:
 1535   
                         case 209:
 1536   
                             {
 1537  9284 
                             alt9=1;
 1538   
                             }
 1539   
                             break;
 1540   
 
 1541  1656 
                         }
 1542  1656 
 
 1543  10574 
                         switch (alt9) {
 1544  1656 
                             case 1 :
 1545   
                                 // com\\googlecode\\sparkleg\\Sparql.g:126:37: v+= selectVariables
 1546  1656 
                                 {
 1547  8310 
                                 pushFollow(FOLLOW_selectVariables_in_selectClause567);
 1548  8310 
                                 v=selectVariables();
 1549   
 
 1550  6654 
                                 state._fsp--;
 1551   
 
 1552  8310 
                                 stream_selectVariables.add(v.getTree());
 1553  6654 
                                 if (list_v==null) list_v=new ArrayList();
 1554  6654 
                                 list_v.add(v.getTree());
 1555  974 
 
 1556   
 
 1557   
                                 }
 1558  6654 
                                 break;
 1559   
 
 1560  1656 
                             default :
 1561  5576 
                                 if ( cnt9 >= 1 ) break loop9;
 1562  0 
                                 EarlyExitException eee =
 1563   
                                     new EarlyExitException(9, input);
 1564  0 
                                 throw eee;
 1565   
                         }
 1566  6654 
                         cnt9++;
 1567  6654 
                     } while (true);
 1568   
 
 1569   
 
 1570   
                     // AST REWRITE
 1571  974 
                     // elements: DISTINCT, v, REDUCED
 1572  974 
                     // token labels:
 1573  974 
                     // rule labels: retval
 1574  974 
                     // token list labels:
 1575   
                     // rule list labels: v
 1576   
                     // wildcard labels:
 1577  3920 
                     retval.tree = root_0;
 1578  3920 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1579  4894 
                     RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 1580  4894 
                     root_0 = (Object)adaptor.nil();
 1581   
                     // 126:58: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1582   
                     {
 1583   
                         // com\\googlecode\\sparkleg\\Sparql.g:126:61: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1584   
                         {
 1585  4936 
                         Object root_1 = (Object)adaptor.nil();
 1586  3962 
                         root_1 = (Object)adaptor.becomeRoot(
 1587   
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1588   
                         , root_1);
 1589   
 
 1590   
                         // com\\googlecode\\sparkleg\\Sparql.g:126:77: ( DISTINCT )*
 1591  5062 
                         while ( stream_DISTINCT.hasNext() ) {
 1592  168 
                             adaptor.addChild(root_1,
 1593   
                             stream_DISTINCT.nextNode()
 1594  984 
                             );
 1595  10 
 
 1596   
                         }
 1597  3920 
                         stream_DISTINCT.reset();
 1598   
 
 1599   
                         // com\\googlecode\\sparkleg\\Sparql.g:126:87: ( REDUCED )*
 1600  4934 
                         while ( stream_REDUCED.hasNext() ) {
 1601  40 
                             adaptor.addChild(root_1,
 1602   
                             stream_REDUCED.nextNode()
 1603  2630 
                             );
 1604  1656 
 
 1605   
                         }
 1606  3920 
                         stream_REDUCED.reset();
 1607  974 
 
 1608   
                         // com\\googlecode\\sparkleg\\Sparql.g:126:97: ( $v)*
 1609  11548 
                         while ( stream_v.hasNext() ) {
 1610  6654 
                             adaptor.addChild(root_1, stream_v.nextTree());
 1611   
 
 1612   
                         }
 1613  3920 
                         stream_v.reset();
 1614   
 
 1615  4894 
                         adaptor.addChild(root_0, root_1);
 1616   
                         }
 1617   
 
 1618   
                     }
 1619   
 
 1620   
 
 1621  5580 
                     retval.tree = root_0;
 1622   
 
 1623   
                     }
 1624  1660 
                     break;
 1625  1660 
 
 1626   
             }
 1627  6460 
             retval.stop = input.LT(-1);
 1628   
 
 1629   
 
 1630  6460 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1631  6460 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1632   
 
 1633   
         }
 1634  0 
         catch (RecognitionException re) {
 1635  0 
             reportError(re);
 1636  0 
             recover(input,re);
 1637  1660 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1638  1660 
 
 1639   
         }
 1640   
 
 1641  0 
         finally {
 1642   
                 // do for sure before leaving
 1643  6460 
         }
 1644  6460 
         return retval;
 1645  3312 
     }
 1646   
     // $ANTLR end "selectClause"
 1647   
 
 1648   
 
 1649  6654 
     public static class selectVariables_return extends ParserRuleReturnScope {
 1650   
         Object tree;
 1651  13308 
         public Object getTree() { return tree; }
 1652  1656 
     };
 1653  1656 
 
 1654   
 
 1655   
     // $ANTLR start "selectVariables"
 1656  1656 
     // com\\googlecode\\sparkleg\\Sparql.g:129:1: selectVariables : ( var -> ^( VAR var ) | '(' expression AS var ')' -> ^( AS expression var ) );
 1657   
     public final SparqlParser.selectVariables_return selectVariables() throws RecognitionException {
 1658  8310 
         SparqlParser.selectVariables_return retval = new SparqlParser.selectVariables_return();
 1659  8310 
         retval.start = input.LT(1);
 1660  1656 
 
 1661  1656 
 
 1662  6654 
         Object root_0 = null;
 1663  1656 
 
 1664  6654 
         Token char_literal34=null;
 1665  8310 
         Token AS36=null;
 1666  6654 
         Token char_literal38=null;
 1667  6654 
         SparqlParser.var_return var33 =null;
 1668  1656 
 
 1669  8310 
         SparqlParser.expression_return expression35 =null;
 1670  1656 
 
 1671  8310 
         SparqlParser.var_return var37 =null;
 1672  1656 
 
 1673  1656 
 
 1674  8310 
         Object char_literal34_tree=null;
 1675  8310 
         Object AS36_tree=null;
 1676  6654 
         Object char_literal38_tree=null;
 1677  6654 
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 1678  8310 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 1679  8310 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 1680  6654 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 1681  6654 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 1682   
         try {
 1683  1406 
             // com\\googlecode\\sparkleg\\Sparql.g:130:5: ( var -> ^( VAR var ) | '(' expression AS var ')' -> ^( AS expression var ) )
 1684  6654 
             int alt11=2;
 1685  8060 
             switch ( input.LA(1) ) {
 1686   
             case VAR1:
 1687   
             case VAR2:
 1688  250 
                 {
 1689  5654 
                 alt11=1;
 1690  250 
                 }
 1691  5654 
                 break;
 1692   
             case 209:
 1693   
                 {
 1694  1000 
                 alt11=2;
 1695   
                 }
 1696  1000 
                 break;
 1697   
             default:
 1698  0 
                 NoViableAltException nvae =
 1699  1656 
                     new NoViableAltException("", 11, 0, input);
 1700   
 
 1701  0 
                 throw nvae;
 1702   
 
 1703  1406 
             }
 1704  1406 
 
 1705  6654 
             switch (alt11) {
 1706  1406 
                 case 1 :
 1707   
                     // com\\googlecode\\sparkleg\\Sparql.g:130:7: var
 1708  1406 
                     {
 1709  5654 
                     pushFollow(FOLLOW_var_in_selectVariables602);
 1710  5654 
                     var33=var();
 1711   
 
 1712  5654 
                     state._fsp--;
 1713   
 
 1714  5654 
                     stream_var.add(var33.getTree());
 1715   
 
 1716   
                     // AST REWRITE
 1717  1406 
                     // elements: var
 1718  1406 
                     // token labels:
 1719   
                     // rule labels: retval
 1720  1406 
                     // token list labels:
 1721   
                     // rule list labels:
 1722   
                     // wildcard labels:
 1723  5654 
                     retval.tree = root_0;
 1724  5654 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1725  1406 
 
 1726  7060 
                     root_0 = (Object)adaptor.nil();
 1727   
                     // 130:11: -> ^( VAR var )
 1728   
                     {
 1729   
                         // com\\googlecode\\sparkleg\\Sparql.g:130:14: ^( VAR var )
 1730  1406 
                         {
 1731  5654 
                         Object root_1 = (Object)adaptor.nil();
 1732  7060 
                         root_1 = (Object)adaptor.becomeRoot(
 1733   
                         (Object)adaptor.create(VAR, "VAR")
 1734   
                         , root_1);
 1735   
 
 1736  5654 
                         adaptor.addChild(root_1, stream_var.nextTree());
 1737   
 
 1738  7060 
                         adaptor.addChild(root_0, root_1);
 1739   
                         }
 1740   
 
 1741  1406 
                     }
 1742   
 
 1743   
 
 1744  5654 
                     retval.tree = root_0;
 1745  250 
 
 1746  250 
                     }
 1747  5654 
                     break;
 1748   
                 case 2 :
 1749  250 
                     // com\\googlecode\\sparkleg\\Sparql.g:131:7: '(' expression AS var ')'
 1750  250 
                     {
 1751  1000 
                     char_literal34=(Token)match(input,209,FOLLOW_209_in_selectVariables619);
 1752  1250 
                     stream_209.add(char_literal34);
 1753   
 
 1754  250 
 
 1755  1000 
                     pushFollow(FOLLOW_expression_in_selectVariables621);
 1756  1250 
                     expression35=expression();
 1757  250 
 
 1758  1000 
                     state._fsp--;
 1759   
 
 1760  1250 
                     stream_expression.add(expression35.getTree());
 1761  250 
 
 1762  1000 
                     AS36=(Token)match(input,AS,FOLLOW_AS_in_selectVariables623);
 1763  1250 
                     stream_AS.add(AS36);
 1764   
 
 1765  250 
 
 1766  1000 
                     pushFollow(FOLLOW_var_in_selectVariables625);
 1767  1250 
                     var37=var();
 1768  250 
 
 1769  1000 
                     state._fsp--;
 1770   
 
 1771  1000 
                     stream_var.add(var37.getTree());
 1772   
 
 1773  1000 
                     char_literal38=(Token)match(input,210,FOLLOW_210_in_selectVariables627);
 1774  1000 
                     stream_210.add(char_literal38);
 1775   
 
 1776   
 
 1777   
                     // AST REWRITE
 1778  250 
                     // elements: expression, AS, var
 1779  250 
                     // token labels:
 1780   
                     // rule labels: retval
 1781  250 
                     // token list labels:
 1782   
                     // rule list labels:
 1783   
                     // wildcard labels:
 1784  1000 
                     retval.tree = root_0;
 1785  1000 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1786  250 
 
 1787  1250 
                     root_0 = (Object)adaptor.nil();
 1788   
                     // 131:33: -> ^( AS expression var )
 1789   
                     {
 1790   
                         // com\\googlecode\\sparkleg\\Sparql.g:131:36: ^( AS expression var )
 1791  250 
                         {
 1792  1000 
                         Object root_1 = (Object)adaptor.nil();
 1793  1250 
                         root_1 = (Object)adaptor.becomeRoot(
 1794   
                         stream_AS.nextNode()
 1795  250 
                         , root_1);
 1796   
 
 1797  1000 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 1798   
 
 1799  1000 
                         adaptor.addChild(root_1, stream_var.nextTree());
 1800   
 
 1801  1250 
                         adaptor.addChild(root_0, root_1);
 1802   
                         }
 1803   
 
 1804   
                     }
 1805   
 
 1806   
 
 1807  2656 
                     retval.tree = root_0;
 1808   
 
 1809   
                     }
 1810  1656 
                     break;
 1811  1656 
 
 1812   
             }
 1813  6654 
             retval.stop = input.LT(-1);
 1814   
 
 1815   
 
 1816  6654 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1817  6654 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1818   
 
 1819   
         }
 1820  0 
         catch (RecognitionException re) {
 1821  0 
             reportError(re);
 1822  0 
             recover(input,re);
 1823  1656 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1824  1656 
 
 1825   
         }
 1826   
 
 1827  0 
         finally {
 1828   
                 // do for sure before leaving
 1829  6654 
         }
 1830  6654 
         return retval;
 1831  72 
     }
 1832   
     // $ANTLR end "selectVariables"
 1833   
 
 1834   
 
 1835  270 
     public static class constructQuery_return extends ParserRuleReturnScope {
 1836   
         Object tree;
 1837  270 
         public Object getTree() { return tree; }
 1838  72 
     };
 1839  72 
 
 1840   
 
 1841   
     // $ANTLR start "constructQuery"
 1842  72 
     // com\\googlecode\\sparkleg\\Sparql.g:134:1: constructQuery : ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE '{' ( triplesTemplate )? '}' solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( triplesTemplate )* ) ( solutionModifier )* ) );
 1843   
     public final SparqlParser.constructQuery_return constructQuery() throws RecognitionException {
 1844  342 
         SparqlParser.constructQuery_return retval = new SparqlParser.constructQuery_return();
 1845  342 
         retval.start = input.LT(1);
 1846  72 
 
 1847  72 
 
 1848  342 
         Object root_0 = null;
 1849  72 
 
 1850  270 
         Token CONSTRUCT39=null;
 1851  342 
         Token CONSTRUCT44=null;
 1852  270 
         Token WHERE46=null;
 1853  342 
         Token char_literal47=null;
 1854  270 
         Token char_literal49=null;
 1855  342 
         SparqlParser.constructTemplate_return constructTemplate40 =null;
 1856   
 
 1857  342 
         SparqlParser.datasetClause_return datasetClause41 =null;
 1858   
 
 1859  342 
         SparqlParser.whereClause_return whereClause42 =null;
 1860   
 
 1861  342 
         SparqlParser.solutionModifier_return solutionModifier43 =null;
 1862   
 
 1863  270 
         SparqlParser.datasetClause_return datasetClause45 =null;
 1864  72 
 
 1865  342 
         SparqlParser.triplesTemplate_return triplesTemplate48 =null;
 1866  72 
 
 1867  342 
         SparqlParser.solutionModifier_return solutionModifier50 =null;
 1868  72 
 
 1869  72 
 
 1870  342 
         Object CONSTRUCT39_tree=null;
 1871  342 
         Object CONSTRUCT44_tree=null;
 1872  342 
         Object WHERE46_tree=null;
 1873  342 
         Object char_literal47_tree=null;
 1874  342 
         Object char_literal49_tree=null;
 1875  342 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 1876  342 
         RewriteRuleTokenStream stream_CONSTRUCT=new RewriteRuleTokenStream(adaptor,"token CONSTRUCT");
 1877  342 
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 1878  270 
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 1879  270 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1880  342 
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 1881  342 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 1882  270 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1883  270 
         RewriteRuleSubtreeStream stream_constructTemplate=new RewriteRuleSubtreeStream(adaptor,"rule constructTemplate");
 1884  72 
         try {
 1885   
             // com\\googlecode\\sparkleg\\Sparql.g:135:5: ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE '{' ( triplesTemplate )? '}' solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( triplesTemplate )* ) ( solutionModifier )* ) )
 1886  270 
             int alt15=2;
 1887  324 
             switch ( input.LA(1) ) {
 1888   
             case CONSTRUCT:
 1889  54 
                 {
 1890  270 
                 switch ( input.LA(2) ) {
 1891   
                 case 216:
 1892   
                     {
 1893  232 
                     alt15=1;
 1894   
                     }
 1895  232 
                     break;
 1896   
                 case FROM:
 1897  2 
                 case WHERE:
 1898   
                     {
 1899  52 
                     alt15=2;
 1900  2 
                     }
 1901  52 
                     break;
 1902   
                 default:
 1903  2 
                     NoViableAltException nvae =
 1904   
                         new NoViableAltException("", 15, 1, input);
 1905  70 
 
 1906  2 
                     throw nvae;
 1907   
 
 1908   
                 }
 1909   
 
 1910   
                 }
 1911  268 
                 break;
 1912   
             default:
 1913  0 
                 NoViableAltException nvae =
 1914  70 
                     new NoViableAltException("", 15, 0, input);
 1915   
 
 1916  0 
                 throw nvae;
 1917   
 
 1918  54 
             }
 1919  54 
 
 1920  268 
             switch (alt15) {
 1921   
                 case 1 :
 1922  54 
                     // com\\googlecode\\sparkleg\\Sparql.g:135:7: CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier
 1923  54 
                     {
 1924  216 
                     CONSTRUCT39=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery654);
 1925  270 
                     stream_CONSTRUCT.add(CONSTRUCT39);
 1926   
 
 1927  54 
 
 1928  216 
                     pushFollow(FOLLOW_constructTemplate_in_constructQuery656);
 1929  216 
                     constructTemplate40=constructTemplate();
 1930   
 
 1931  216 
                     state._fsp--;
 1932  54 
 
 1933  270 
                     stream_constructTemplate.add(constructTemplate40.getTree());
 1934   
 
 1935   
                     // com\\googlecode\\sparkleg\\Sparql.g:135:35: ( datasetClause )*
 1936   
                     loop12:
 1937   
                     do {
 1938  216 
                         int alt12=2;
 1939  216 
                         switch ( input.LA(1) ) {
 1940   
                         case FROM:
 1941   
                             {
 1942  54 
                             alt12=1;
 1943   
                             }
 1944   
                             break;
 1945   
 
 1946   
                         }
 1947   
 
 1948  216 
                         switch (alt12) {
 1949   
                             case 1 :
 1950   
                                 // com\\googlecode\\sparkleg\\Sparql.g:135:35: datasetClause
 1951   
                                 {
 1952  0 
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery658);
 1953  0 
                                 datasetClause41=datasetClause();
 1954   
 
 1955  0 
                                 state._fsp--;
 1956   
 
 1957  54 
                                 stream_datasetClause.add(datasetClause41.getTree());
 1958   
 
 1959   
                                 }
 1960  0 
                                 break;
 1961   
 
 1962  54 
                             default :
 1963  270 
                                 break loop12;
 1964   
                         }
 1965  54 
                     } while (true);
 1966   
 
 1967  54 
 
 1968  216 
                     pushFollow(FOLLOW_whereClause_in_constructQuery661);
 1969  270 
                     whereClause42=whereClause();
 1970  54 
 
 1971  216 
                     state._fsp--;
 1972  54 
 
 1973  216 
                     stream_whereClause.add(whereClause42.getTree());
 1974  54 
 
 1975  216 
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery663);
 1976  216 
                     solutionModifier43=solutionModifier();
 1977   
 
 1978  216 
                     state._fsp--;
 1979   
 
 1980  216 
                     stream_solutionModifier.add(solutionModifier43.getTree());
 1981   
 
 1982   
                     // AST REWRITE
 1983  54 
                     // elements: whereClause, constructTemplate, CONSTRUCT, solutionModifier, datasetClause
 1984  54 
                     // token labels:
 1985   
                     // rule labels: retval
 1986  54 
                     // token list labels:
 1987   
                     // rule list labels:
 1988   
                     // wildcard labels:
 1989  216 
                     retval.tree = root_0;
 1990  216 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1991  54 
 
 1992  270 
                     root_0 = (Object)adaptor.nil();
 1993   
                     // 135:79: -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1994   
                     {
 1995   
                         // com\\googlecode\\sparkleg\\Sparql.g:135:82: ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1996  54 
                         {
 1997  216 
                         Object root_1 = (Object)adaptor.nil();
 1998  216 
                         root_1 = (Object)adaptor.becomeRoot(
 1999  54 
                         stream_CONSTRUCT.nextNode()
 2000   
                         , root_1);
 2001   
 
 2002  216 
                         adaptor.addChild(root_1, stream_constructTemplate.nextTree());
 2003  54 
 
 2004   
                         // com\\googlecode\\sparkleg\\Sparql.g:135:112: ( datasetClause )*
 2005  216 
                         while ( stream_datasetClause.hasNext() ) {
 2006  108 
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2007  54 
 
 2008   
                         }
 2009  216 
                         stream_datasetClause.reset();
 2010  54 
 
 2011   
                         // com\\googlecode\\sparkleg\\Sparql.g:135:127: ( whereClause )*
 2012  432 
                         while ( stream_whereClause.hasNext() ) {
 2013  276 
                             adaptor.addChild(root_1, stream_whereClause.nextTree());
 2014  6 
 
 2015   
                         }
 2016  216 
                         stream_whereClause.reset();
 2017  54 
 
 2018   
                         // com\\googlecode\\sparkleg\\Sparql.g:135:140: ( solutionModifier )*
 2019  294 
                         while ( stream_solutionModifier.hasNext() ) {
 2020  24 
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2021   
 
 2022   
                         }
 2023  216 
                         stream_solutionModifier.reset();
 2024   
 
 2025  270 
                         adaptor.addChild(root_0, root_1);
 2026   
                         }
 2027   
 
 2028  54 
                     }
 2029   
 
 2030   
 
 2031  216 
                     retval.tree = root_0;
 2032  16 
 
 2033  16 
                     }
 2034  216 
                     break;
 2035   
                 case 2 :
 2036   
                     // com\\googlecode\\sparkleg\\Sparql.g:136:7: CONSTRUCT ( datasetClause )* WHERE '{' ( triplesTemplate )? '}' solutionModifier
 2037   
                     {
 2038  52 
                     CONSTRUCT44=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery691);
 2039  70 
                     stream_CONSTRUCT.add(CONSTRUCT44);
 2040  18 
 
 2041   
 
 2042   
                     // com\\googlecode\\sparkleg\\Sparql.g:136:17: ( datasetClause )*
 2043  2 
                     loop13:
 2044   
                     do {
 2045  60 
                         int alt13=2;
 2046  60 
                         switch ( input.LA(1) ) {
 2047   
                         case FROM:
 2048   
                             {
 2049  26 
                             alt13=1;
 2050   
                             }
 2051   
                             break;
 2052   
 
 2053  2 
                         }
 2054  2 
 
 2055  60 
                         switch (alt13) {
 2056  2 
                             case 1 :
 2057   
                                 // com\\googlecode\\sparkleg\\Sparql.g:136:17: datasetClause
 2058  2 
                                 {
 2059  8 
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery693);
 2060  8 
                                 datasetClause45=datasetClause();
 2061  2 
 
 2062  8 
                                 state._fsp--;
 2063   
 
 2064  24 
                                 stream_datasetClause.add(datasetClause45.getTree());
 2065   
 
 2066  2 
                                 }
 2067  8 
                                 break;
 2068   
 
 2069  16 
                             default :
 2070  68 
                                 break loop13;
 2071   
                         }
 2072  8 
                     } while (true);
 2073  16 
 
 2074  16 
 
 2075  52 
                     WHERE46=(Token)match(input,WHERE,FOLLOW_WHERE_in_constructQuery696);
 2076  52 
                     stream_WHERE.add(WHERE46);
 2077   
 
 2078  16 
 
 2079  68 
                     char_literal47=(Token)match(input,216,FOLLOW_216_in_constructQuery698);
 2080  52 
                     stream_216.add(char_literal47);
 2081   
 
 2082   
 
 2083   
                     // com\\googlecode\\sparkleg\\Sparql.g:136:42: ( triplesTemplate )?
 2084  52 
                     int alt14=2;
 2085  52 
                     switch ( input.LA(1) ) {
 2086   
                         case BLANK_NODE_LABEL:
 2087   
                         case DECIMAL:
 2088   
                         case DECIMAL_NEGATIVE:
 2089   
                         case DECIMAL_POSITIVE:
 2090   
                         case DOUBLE:
 2091   
                         case DOUBLE_NEGATIVE:
 2092   
                         case DOUBLE_POSITIVE:
 2093   
                         case FALSE:
 2094   
                         case INTEGER:
 2095   
                         case INTEGER_NEGATIVE:
 2096   
                         case INTEGER_POSITIVE:
 2097   
                         case IRI_REF:
 2098   
                         case PNAME_LN:
 2099   
                         case PNAME_NS:
 2100   
                         case STRING_LITERAL1:
 2101   
                         case STRING_LITERAL2:
 2102   
                         case STRING_LITERAL_LONG1:
 2103   
                         case STRING_LITERAL_LONG2:
 2104  14 
                         case TRUE:
 2105   
                         case VAR1:
 2106   
                         case VAR2:
 2107   
                         case 209:
 2108   
                         case 213:
 2109  16 
                             {
 2110  50 
                             alt14=1;
 2111   
                             }
 2112   
                             break;
 2113  14 
                     }
 2114  14 
 
 2115  52 
                     switch (alt14) {
 2116  14 
                         case 1 :
 2117   
                             // com\\googlecode\\sparkleg\\Sparql.g:136:42: triplesTemplate
 2118  14 
                             {
 2119  50 
                             pushFollow(FOLLOW_triplesTemplate_in_constructQuery700);
 2120  50 
                             triplesTemplate48=triplesTemplate();
 2121   
 
 2122  50 
                             state._fsp--;
 2123   
 
 2124  50 
                             stream_triplesTemplate.add(triplesTemplate48.getTree());
 2125   
 
 2126  16 
                             }
 2127  12 
                             break;
 2128   
 
 2129   
                     }
 2130  12 
 
 2131  12 
 
 2132  52 
                     char_literal49=(Token)match(input,218,FOLLOW_218_in_constructQuery703);
 2133  60 
                     stream_218.add(char_literal49);
 2134   
 
 2135  12 
 
 2136  48 
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery705);
 2137  48 
                     solutionModifier50=solutionModifier();
 2138   
 
 2139  48 
                     state._fsp--;
 2140   
 
 2141  48 
                     stream_solutionModifier.add(solutionModifier50.getTree());
 2142   
 
 2143   
                     // AST REWRITE
 2144  12 
                     // elements: solutionModifier, CONSTRUCT, triplesTemplate, datasetClause
 2145  12 
                     // token labels:
 2146   
                     // rule labels: retval
 2147  12 
                     // token list labels:
 2148   
                     // rule list labels:
 2149   
                     // wildcard labels:
 2150  48 
                     retval.tree = root_0;
 2151  48 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2152  12 
 
 2153  60 
                     root_0 = (Object)adaptor.nil();
 2154   
                     // 136:80: -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( triplesTemplate )* ) ( solutionModifier )* )
 2155   
                     {
 2156   
                         // com\\googlecode\\sparkleg\\Sparql.g:136:83: ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( triplesTemplate )* ) ( solutionModifier )* )
 2157   
                         {
 2158  62 
                         Object root_1 = (Object)adaptor.nil();
 2159  50 
                         root_1 = (Object)adaptor.becomeRoot(
 2160   
                         stream_CONSTRUCT.nextNode()
 2161   
                         , root_1);
 2162  12 
 
 2163   
                         // com\\googlecode\\sparkleg\\Sparql.g:136:95: ( datasetClause )*
 2164  56 
                         while ( stream_datasetClause.hasNext() ) {
 2165  8 
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2166  12 
 
 2167  12 
                         }
 2168  48 
                         stream_datasetClause.reset();
 2169   
 
 2170   
                         // com\\googlecode\\sparkleg\\Sparql.g:136:110: ^( WHERE_CLAUSE ( triplesTemplate )* )
 2171   
                         {
 2172  72 
                         Object root_2 = (Object)adaptor.nil();
 2173  60 
                         root_2 = (Object)adaptor.becomeRoot(
 2174   
                         (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2175   
                         , root_2);
 2176  12 
 
 2177   
                         // com\\googlecode\\sparkleg\\Sparql.g:136:125: ( triplesTemplate )*
 2178  108 
                         while ( stream_triplesTemplate.hasNext() ) {
 2179  48 
                             adaptor.addChild(root_2, stream_triplesTemplate.nextTree());
 2180   
 
 2181   
                         }
 2182  60 
                         stream_triplesTemplate.reset();
 2183   
 
 2184  48 
                         adaptor.addChild(root_1, root_2);
 2185   
                         }
 2186  12 
 
 2187   
                         // com\\googlecode\\sparkleg\\Sparql.g:136:143: ( solutionModifier )*
 2188  60 
                         while ( stream_solutionModifier.hasNext() ) {
 2189  0 
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2190   
 
 2191   
                         }
 2192  48 
                         stream_solutionModifier.reset();
 2193   
 
 2194  60 
                         adaptor.addChild(root_0, root_1);
 2195   
                         }
 2196   
 
 2197   
                     }
 2198   
 
 2199   
 
 2200  114 
                     retval.tree = root_0;
 2201   
 
 2202   
                     }
 2203  66 
                     break;
 2204  66 
 
 2205   
             }
 2206  264 
             retval.stop = input.LT(-1);
 2207  6 
 
 2208  6 
 
 2209  270 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2210  270 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2211   
 
 2212   
         }
 2213  6 
         catch (RecognitionException re) {
 2214  6 
             reportError(re);
 2215  6 
             recover(input,re);
 2216  78 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2217  72 
 
 2218   
         }
 2219   
 
 2220  0 
         finally {
 2221   
                 // do for sure before leaving
 2222  270 
         }
 2223  270 
         return retval;
 2224  28 
     }
 2225   
     // $ANTLR end "constructQuery"
 2226   
 
 2227   
 
 2228  112 
     public static class describeQuery_return extends ParserRuleReturnScope {
 2229   
         Object tree;
 2230  112 
         public Object getTree() { return tree; }
 2231  28 
     };
 2232  28 
 
 2233   
 
 2234   
     // $ANTLR start "describeQuery"
 2235  28 
     // com\\googlecode\\sparkleg\\Sparql.g:139:1: describeQuery : DESCRIBE ( (v+= varOrIRIref )+ | '*' ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( '*' )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) ;
 2236   
     public final SparqlParser.describeQuery_return describeQuery() throws RecognitionException {
 2237  140 
         SparqlParser.describeQuery_return retval = new SparqlParser.describeQuery_return();
 2238  140 
         retval.start = input.LT(1);
 2239  28 
 
 2240  28 
 
 2241  112 
         Object root_0 = null;
 2242  28 
 
 2243  112 
         Token DESCRIBE51=null;
 2244  140 
         Token char_literal52=null;
 2245  112 
         List list_v=null;
 2246  140 
         SparqlParser.datasetClause_return datasetClause53 =null;
 2247  28 
 
 2248  140 
         SparqlParser.whereClause_return whereClause54 =null;
 2249  28 
 
 2250  140 
         SparqlParser.solutionModifier_return solutionModifier55 =null;
 2251  28 
 
 2252  140 
         RuleReturnScope v = null;
 2253  140 
         Object DESCRIBE51_tree=null;
 2254  140 
         Object char_literal52_tree=null;
 2255  112 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 2256  112 
         RewriteRuleTokenStream stream_DESCRIBE=new RewriteRuleTokenStream(adaptor,"token DESCRIBE");
 2257  112 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 2258  112 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2259  140 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2260  140 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 2261   
         try {
 2262   
             // com\\googlecode\\sparkleg\\Sparql.g:140:5: ( DESCRIBE ( (v+= varOrIRIref )+ | '*' ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( '*' )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) )
 2263   
             // com\\googlecode\\sparkleg\\Sparql.g:140:7: DESCRIBE ( (v+= varOrIRIref )+ | '*' ) ( datasetClause )* ( whereClause )? solutionModifier
 2264  28 
             {
 2265  140 
             DESCRIBE51=(Token)match(input,DESCRIBE,FOLLOW_DESCRIBE_in_describeQuery741);
 2266  112 
             stream_DESCRIBE.add(DESCRIBE51);
 2267   
 
 2268   
 
 2269   
             // com\\googlecode\\sparkleg\\Sparql.g:140:16: ( (v+= varOrIRIref )+ | '*' )
 2270  112 
             int alt17=2;
 2271  112 
             switch ( input.LA(1) ) {
 2272  28 
             case IRI_REF:
 2273   
             case PNAME_LN:
 2274  28 
             case PNAME_NS:
 2275   
             case VAR1:
 2276   
             case VAR2:
 2277   
                 {
 2278  112 
                 alt17=1;
 2279   
                 }
 2280  112 
                 break;
 2281   
             case ASTERISK:
 2282   
                 {
 2283  0 
                 alt17=2;
 2284   
                 }
 2285  0 
                 break;
 2286   
             default:
 2287  0 
                 NoViableAltException nvae =
 2288  28 
                     new NoViableAltException("", 17, 0, input);
 2289   
 
 2290  0 
                 throw nvae;
 2291   
 
 2292   
             }
 2293  28 
 
 2294  112 
             switch (alt17) {
 2295   
                 case 1 :
 2296  70 
                     // com\\googlecode\\sparkleg\\Sparql.g:140:17: (v+= varOrIRIref )+
 2297  70 
                     {
 2298   
                     // com\\googlecode\\sparkleg\\Sparql.g:140:17: (v+= varOrIRIref )+
 2299  112 
                     int cnt16=0;
 2300   
                     loop16:
 2301   
                     do {
 2302  280 
                         int alt16=2;
 2303  280 
                         switch ( input.LA(1) ) {
 2304  42 
                         case IRI_REF:
 2305   
                         case PNAME_LN:
 2306   
                         case PNAME_NS:
 2307   
                         case VAR1:
 2308   
                         case VAR2:
 2309   
                             {
 2310  238 
                             alt16=1;
 2311   
                             }
 2312   
                             break;
 2313   
 
 2314  42 
                         }
 2315  42 
 
 2316  280 
                         switch (alt16) {
 2317  42 
                             case 1 :
 2318   
                                 // com\\googlecode\\sparkleg\\Sparql.g:140:18: v+= varOrIRIref
 2319  42 
                                 {
 2320  210 
                                 pushFollow(FOLLOW_varOrIRIref_in_describeQuery747);
 2321  210 
                                 v=varOrIRIref();
 2322   
 
 2323  168 
                                 state._fsp--;
 2324   
 
 2325  210 
                                 stream_varOrIRIref.add(v.getTree());
 2326  168 
                                 if (list_v==null) list_v=new ArrayList();
 2327  168 
                                 list_v.add(v.getTree());
 2328  28 
 
 2329   
 
 2330   
                                 }
 2331  168 
                                 break;
 2332   
 
 2333  42 
                             default :
 2334  154 
                                 if ( cnt16 >= 1 ) break loop16;
 2335  0 
                                 EarlyExitException eee =
 2336   
                                     new EarlyExitException(16, input);
 2337  0 
                                 throw eee;
 2338  28 
                         }
 2339  168 
                         cnt16++;
 2340  168 
                     } while (true);
 2341   
 
 2342   
 
 2343   
                     }
 2344  112 
                     break;
 2345   
                 case 2 :
 2346   
                     // com\\googlecode\\sparkleg\\Sparql.g:140:37: '*'
 2347   
                     {
 2348  0 
                     char_literal52=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_describeQuery753);
 2349  0 
                     stream_ASTERISK.add(char_literal52);
 2350   
 
 2351   
 
 2352   
                     }
 2353   
                     break;
 2354   
 
 2355  28 
             }
 2356  28 
 
 2357   
 
 2358   
             // com\\googlecode\\sparkleg\\Sparql.g:140:42: ( datasetClause )*
 2359   
             loop18:
 2360   
             do {
 2361  112 
                 int alt18=2;
 2362  112 
                 switch ( input.LA(1) ) {
 2363   
                 case FROM:
 2364   
                     {
 2365  28 
                     alt18=1;
 2366   
                     }
 2367   
                     break;
 2368   
 
 2369   
                 }
 2370   
 
 2371  112 
                 switch (alt18) {
 2372   
                     case 1 :
 2373   
                         // com\\googlecode\\sparkleg\\Sparql.g:140:42: datasetClause
 2374   
                         {
 2375  0 
                         pushFollow(FOLLOW_datasetClause_in_describeQuery756);
 2376  0 
                         datasetClause53=datasetClause();
 2377   
 
 2378  0 
                         state._fsp--;
 2379   
 
 2380  28 
                         stream_datasetClause.add(datasetClause53.getTree());
 2381   
 
 2382   
                         }
 2383  0 
                         break;
 2384   
 
 2385   
                     default :
 2386  140 
                         break loop18;
 2387  28 
                 }
 2388  0 
             } while (true);
 2389   
 
 2390   
 
 2391  22 
             // com\\googlecode\\sparkleg\\Sparql.g:140:57: ( whereClause )?
 2392  112 
             int alt19=2;
 2393  112 
             switch ( input.LA(1) ) {
 2394   
                 case WHERE:
 2395   
                 case 216:
 2396  28 
                     {
 2397  88 
                     alt19=1;
 2398   
                     }
 2399   
                     break;
 2400  22 
             }
 2401  22 
 
 2402  112 
             switch (alt19) {
 2403  22 
                 case 1 :
 2404   
                     // com\\googlecode\\sparkleg\\Sparql.g:140:57: whereClause
 2405  22 
                     {
 2406  88 
                     pushFollow(FOLLOW_whereClause_in_describeQuery759);
 2407  88 
                     whereClause54=whereClause();
 2408   
 
 2409  88 
                     state._fsp--;
 2410   
 
 2411  88 
                     stream_whereClause.add(whereClause54.getTree());
 2412   
 
 2413  28 
                     }
 2414  28 
                     break;
 2415   
 
 2416  28 
             }
 2417   
 
 2418  28 
 
 2419  112 
             pushFollow(FOLLOW_solutionModifier_in_describeQuery762);
 2420  112 
             solutionModifier55=solutionModifier();
 2421   
 
 2422  112 
             state._fsp--;
 2423   
 
 2424  112 
             stream_solutionModifier.add(solutionModifier55.getTree());
 2425   
 
 2426   
             // AST REWRITE
 2427  28 
             // elements: whereClause, solutionModifier, v, datasetClause, DESCRIBE, ASTERISK
 2428  28 
             // token labels:
 2429  28 
             // rule labels: retval
 2430  28 
             // token list labels:
 2431   
             // rule list labels: v
 2432   
             // wildcard labels:
 2433  112 
             retval.tree = root_0;
 2434  112 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2435  140 
             RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 2436  140 
             root_0 = (Object)adaptor.nil();
 2437   
             // 140:87: -> ^( DESCRIBE ( $v)* ( '*' )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2438   
             {
 2439   
                 // com\\googlecode\\sparkleg\\Sparql.g:140:90: ^( DESCRIBE ( $v)* ( '*' )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2440   
                 {
 2441  182 
                 Object root_1 = (Object)adaptor.nil();
 2442  154 
                 root_1 = (Object)adaptor.becomeRoot(
 2443   
                 stream_DESCRIBE.nextNode()
 2444   
                 , root_1);
 2445  28 
 
 2446   
                 // com\\googlecode\\sparkleg\\Sparql.g:140:102: ( $v)*
 2447  280 
                 while ( stream_v.hasNext() ) {
 2448  196 
                     adaptor.addChild(root_1, stream_v.nextTree());
 2449   
 
 2450   
                 }
 2451  112 
                 stream_v.reset();
 2452   
 
 2453   
                 // com\\googlecode\\sparkleg\\Sparql.g:140:105: ( '*' )*
 2454  140 
                 while ( stream_ASTERISK.hasNext() ) {
 2455  0 
                     adaptor.addChild(root_1,
 2456   
                     stream_ASTERISK.nextNode()
 2457  28 
                     );
 2458   
 
 2459   
                 }
 2460  112 
                 stream_ASTERISK.reset();
 2461  28 
 
 2462   
                 // com\\googlecode\\sparkleg\\Sparql.g:140:110: ( datasetClause )*
 2463  112 
                 while ( stream_datasetClause.hasNext() ) {
 2464  28 
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2465  22 
 
 2466   
                 }
 2467  112 
                 stream_datasetClause.reset();
 2468  28 
 
 2469   
                 // com\\googlecode\\sparkleg\\Sparql.g:140:125: ( whereClause )?
 2470  112 
                 if ( stream_whereClause.hasNext() ) {
 2471  116 
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 2472   
 
 2473   
                 }
 2474  112 
                 stream_whereClause.reset();
 2475  28 
 
 2476   
                 // com\\googlecode\\sparkleg\\Sparql.g:140:138: ( solutionModifier )*
 2477  140 
                 while ( stream_solutionModifier.hasNext() ) {
 2478  0 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2479   
 
 2480   
                 }
 2481  112 
                 stream_solutionModifier.reset();
 2482   
 
 2483  140 
                 adaptor.addChild(root_0, root_1);
 2484   
                 }
 2485   
 
 2486   
             }
 2487  28 
 
 2488   
 
 2489  112 
             retval.tree = root_0;
 2490  28 
 
 2491  28 
             }
 2492   
 
 2493  112 
             retval.stop = input.LT(-1);
 2494   
 
 2495   
 
 2496  112 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2497  112 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2498   
 
 2499   
         }
 2500  0 
         catch (RecognitionException re) {
 2501  0 
             reportError(re);
 2502  0 
             recover(input,re);
 2503  28 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2504  28 
 
 2505   
         }
 2506   
 
 2507  0 
         finally {
 2508   
                 // do for sure before leaving
 2509  112 
         }
 2510  112 
         return retval;
 2511  120 
     }
 2512   
     // $ANTLR end "describeQuery"
 2513   
 
 2514   
 
 2515  486 
     public static class askQuery_return extends ParserRuleReturnScope {
 2516   
         Object tree;
 2517  486 
         public Object getTree() { return tree; }
 2518  120 
     };
 2519  120 
 
 2520   
 
 2521   
     // $ANTLR start "askQuery"
 2522  120 
     // com\\googlecode\\sparkleg\\Sparql.g:143:1: askQuery : ASK ( datasetClause )* whereClause solutionModifier -> ^( ASK ( datasetClause )* whereClause ( solutionModifier )* ) ;
 2523   
     public final SparqlParser.askQuery_return askQuery() throws RecognitionException {
 2524  606 
         SparqlParser.askQuery_return retval = new SparqlParser.askQuery_return();
 2525  606 
         retval.start = input.LT(1);
 2526   
 
 2527  120 
 
 2528  486 
         Object root_0 = null;
 2529  120 
 
 2530  486 
         Token ASK56=null;
 2531  486 
         SparqlParser.datasetClause_return datasetClause57 =null;
 2532  120 
 
 2533  606 
         SparqlParser.whereClause_return whereClause58 =null;
 2534  120 
 
 2535  606 
         SparqlParser.solutionModifier_return solutionModifier59 =null;
 2536  120 
 
 2537   
 
 2538  486 
         Object ASK56_tree=null;
 2539  486 
         RewriteRuleTokenStream stream_ASK=new RewriteRuleTokenStream(adaptor,"token ASK");
 2540  486 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2541  606 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2542  606 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 2543   
         try {
 2544   
             // com\\googlecode\\sparkleg\\Sparql.g:144:5: ( ASK ( datasetClause )* whereClause solutionModifier -> ^( ASK ( datasetClause )* whereClause ( solutionModifier )* ) )
 2545   
             // com\\googlecode\\sparkleg\\Sparql.g:144:7: ASK ( datasetClause )* whereClause solutionModifier
 2546   
             {
 2547  486 
             ASK56=(Token)match(input,ASK,FOLLOW_ASK_in_askQuery801);
 2548  606 
             stream_ASK.add(ASK56);
 2549  120 
 
 2550   
 
 2551   
             // com\\googlecode\\sparkleg\\Sparql.g:144:11: ( datasetClause )*
 2552   
             loop20:
 2553   
             do {
 2554  486 
                 int alt20=2;
 2555  486 
                 switch ( input.LA(1) ) {
 2556   
                 case FROM:
 2557   
                     {
 2558  120 
                     alt20=1;
 2559   
                     }
 2560   
                     break;
 2561   
 
 2562   
                 }
 2563   
 
 2564  486 
                 switch (alt20) {
 2565   
                     case 1 :
 2566   
                         // com\\googlecode\\sparkleg\\Sparql.g:144:11: datasetClause
 2567   
                         {
 2568  0 
                         pushFollow(FOLLOW_datasetClause_in_askQuery803);
 2569  0 
                         datasetClause57=datasetClause();
 2570   
 
 2571  0 
                         state._fsp--;
 2572   
 
 2573  120 
                         stream_datasetClause.add(datasetClause57.getTree());
 2574   
 
 2575   
                         }
 2576  0 
                         break;
 2577   
 
 2578  120 
                     default :
 2579  606 
                         break loop20;
 2580   
                 }
 2581  120 
             } while (true);
 2582   
 
 2583  120 
 
 2584  486 
             pushFollow(FOLLOW_whereClause_in_askQuery806);
 2585  606 
             whereClause58=whereClause();
 2586  120 
 
 2587  486 
             state._fsp--;
 2588  120 
 
 2589  486 
             stream_whereClause.add(whereClause58.getTree());
 2590  120 
 
 2591  486 
             pushFollow(FOLLOW_solutionModifier_in_askQuery808);
 2592  486 
             solutionModifier59=solutionModifier();
 2593   
 
 2594  486 
             state._fsp--;
 2595   
 
 2596  486 
             stream_solutionModifier.add(solutionModifier59.getTree());
 2597   
 
 2598   
             // AST REWRITE
 2599  120 
             // elements: whereClause, solutionModifier, datasetClause, ASK
 2600  120 
             // token labels:
 2601   
             // rule labels: retval
 2602  120 
             // token list labels:
 2603   
             // rule list labels:
 2604   
             // wildcard labels:
 2605  486 
             retval.tree = root_0;
 2606  486 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2607  120 
 
 2608  606 
             root_0 = (Object)adaptor.nil();
 2609   
             // 144:55: -> ^( ASK ( datasetClause )* whereClause ( solutionModifier )* )
 2610   
             {
 2611   
                 // com\\googlecode\\sparkleg\\Sparql.g:144:58: ^( ASK ( datasetClause )* whereClause ( solutionModifier )* )
 2612   
                 {
 2613  606 
                 Object root_1 = (Object)adaptor.nil();
 2614  486 
                 root_1 = (Object)adaptor.becomeRoot(
 2615   
                 stream_ASK.nextNode()
 2616   
                 , root_1);
 2617  120 
 
 2618   
                 // com\\googlecode\\sparkleg\\Sparql.g:144:64: ( datasetClause )*
 2619  606 
                 while ( stream_datasetClause.hasNext() ) {
 2620  0 
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2621   
 
 2622  120 
                 }
 2623  486 
                 stream_datasetClause.reset();
 2624   
 
 2625  486 
                 adaptor.addChild(root_1, stream_whereClause.nextTree());
 2626  120 
 
 2627   
                 // com\\googlecode\\sparkleg\\Sparql.g:144:91: ( solutionModifier )*
 2628  606 
                 while ( stream_solutionModifier.hasNext() ) {
 2629  0 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2630   
 
 2631   
                 }
 2632  486 
                 stream_solutionModifier.reset();
 2633   
 
 2634  606 
                 adaptor.addChild(root_0, root_1);
 2635   
                 }
 2636   
 
 2637   
             }
 2638  120 
 
 2639   
 
 2640  486 
             retval.tree = root_0;
 2641  120 
 
 2642  120 
             }
 2643   
 
 2644  486 
             retval.stop = input.LT(-1);
 2645   
 
 2646   
 
 2647  486 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2648  486 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2649   
 
 2650   
         }
 2651  0 
         catch (RecognitionException re) {
 2652  0 
             reportError(re);
 2653  0 
             recover(input,re);
 2654  120 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2655  120 
 
 2656   
         }
 2657   
 
 2658  0 
         finally {
 2659   
                 // do for sure before leaving
 2660  160 
         }
 2661  486 
         return retval;
 2662  160 
     }
 2663   
     // $ANTLR end "askQuery"
 2664   
 
 2665   
 
 2666  640 
     public static class datasetClause_return extends ParserRuleReturnScope {
 2667   
         Object tree;
 2668  640 
         public Object getTree() { return tree; }
 2669  160 
     };
 2670  160 
 
 2671   
 
 2672   
     // $ANTLR start "datasetClause"
 2673  160 
     // com\\googlecode\\sparkleg\\Sparql.g:147:1: datasetClause : FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) ;
 2674   
     public final SparqlParser.datasetClause_return datasetClause() throws RecognitionException {
 2675  800 
         SparqlParser.datasetClause_return retval = new SparqlParser.datasetClause_return();
 2676  800 
         retval.start = input.LT(1);
 2677  160 
 
 2678   
 
 2679  640 
         Object root_0 = null;
 2680  160 
 
 2681  800 
         Token FROM60=null;
 2682  800 
         Token NAMED61=null;
 2683  800 
         SparqlParser.iriRef_return iriRef62 =null;
 2684  160 
 
 2685   
 
 2686  640 
         Object FROM60_tree=null;
 2687  640 
         Object NAMED61_tree=null;
 2688  640 
         RewriteRuleTokenStream stream_FROM=new RewriteRuleTokenStream(adaptor,"token FROM");
 2689  800 
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 2690  800 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 2691   
         try {
 2692   
             // com\\googlecode\\sparkleg\\Sparql.g:148:5: ( FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) )
 2693   
             // com\\googlecode\\sparkleg\\Sparql.g:148:7: FROM ( NAMED )? iriRef
 2694  160 
             {
 2695  800 
             FROM60=(Token)match(input,FROM,FOLLOW_FROM_in_datasetClause839);
 2696  640 
             stream_FROM.add(FROM60);
 2697   
 
 2698  102 
 
 2699   
             // com\\googlecode\\sparkleg\\Sparql.g:148:12: ( NAMED )?
 2700  640 
             int alt21=2;
 2701  640 
             switch ( input.LA(1) ) {
 2702   
                 case NAMED:
 2703  160 
                     {
 2704  408 
                     alt21=1;
 2705   
                     }
 2706   
                     break;
 2707  102 
             }
 2708  102 
 
 2709  640 
             switch (alt21) {
 2710   
                 case 1 :
 2711   
                     // com\\googlecode\\sparkleg\\Sparql.g:148:12: NAMED
 2712   
                     {
 2713  408 
                     NAMED61=(Token)match(input,NAMED,FOLLOW_NAMED_in_datasetClause841);
 2714  408 
                     stream_NAMED.add(NAMED61);
 2715   
 
 2716   
 
 2717  160 
                     }
 2718  160 
                     break;
 2719   
 
 2720  160 
             }
 2721   
 
 2722  160 
 
 2723  640 
             pushFollow(FOLLOW_iriRef_in_datasetClause844);
 2724  640 
             iriRef62=iriRef();
 2725   
 
 2726  640 
             state._fsp--;
 2727   
 
 2728  640 
             stream_iriRef.add(iriRef62.getTree());
 2729   
 
 2730   
             // AST REWRITE
 2731  160 
             // elements: iriRef, FROM, NAMED
 2732  160 
             // token labels:
 2733   
             // rule labels: retval
 2734  160 
             // token list labels:
 2735   
             // rule list labels:
 2736   
             // wildcard labels:
 2737  640 
             retval.tree = root_0;
 2738  640 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2739  160 
 
 2740  800 
             root_0 = (Object)adaptor.nil();
 2741   
             // 148:26: -> ^( FROM ( NAMED )? iriRef )
 2742   
             {
 2743   
                 // com\\googlecode\\sparkleg\\Sparql.g:148:29: ^( FROM ( NAMED )? iriRef )
 2744   
                 {
 2745  800 
                 Object root_1 = (Object)adaptor.nil();
 2746  742 
                 root_1 = (Object)adaptor.becomeRoot(
 2747   
                 stream_FROM.nextNode()
 2748   
                 , root_1);
 2749   
 
 2750   
                 // com\\googlecode\\sparkleg\\Sparql.g:148:36: ( NAMED )?
 2751  800 
                 if ( stream_NAMED.hasNext() ) {
 2752  408 
                     adaptor.addChild(root_1,
 2753  160 
                     stream_NAMED.nextNode()
 2754   
                     );
 2755  160 
 
 2756   
                 }
 2757  640 
                 stream_NAMED.reset();
 2758   
 
 2759  640 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 2760   
 
 2761  800 
                 adaptor.addChild(root_0, root_1);
 2762   
                 }
 2763   
 
 2764   
             }
 2765  160 
 
 2766   
 
 2767  640 
             retval.tree = root_0;
 2768  160 
 
 2769  160 
             }
 2770   
 
 2771  640 
             retval.stop = input.LT(-1);
 2772   
 
 2773   
 
 2774  640 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2775  640 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2776   
 
 2777   
         }
 2778  0 
         catch (RecognitionException re) {
 2779  0 
             reportError(re);
 2780  0 
             recover(input,re);
 2781  160 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2782  160 
 
 2783   
         }
 2784   
 
 2785  0 
         finally {
 2786   
                 // do for sure before leaving
 2787  640 
         }
 2788  640 
         return retval;
 2789  1856 
     }
 2790   
     // $ANTLR end "datasetClause"
 2791   
 
 2792   
 
 2793  7250 
     public static class whereClause_return extends ParserRuleReturnScope {
 2794   
         Object tree;
 2795  7250 
         public Object getTree() { return tree; }
 2796  1856 
     };
 2797  1856 
 
 2798   
 
 2799   
     // $ANTLR start "whereClause"
 2800  1856 
     // com\\googlecode\\sparkleg\\Sparql.g:151:1: whereClause : ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) ;
 2801   
     public final SparqlParser.whereClause_return whereClause() throws RecognitionException {
 2802  9106 
         SparqlParser.whereClause_return retval = new SparqlParser.whereClause_return();
 2803  9106 
         retval.start = input.LT(1);
 2804   
 
 2805   
 
 2806  9106 
         Object root_0 = null;
 2807  1856 
 
 2808  9106 
         Token WHERE63=null;
 2809  7250 
         SparqlParser.groupGraphPattern_return groupGraphPattern64 =null;
 2810   
 
 2811   
 
 2812  7250 
         Object WHERE63_tree=null;
 2813  7250 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 2814  9106 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 2815  1856 
         try {
 2816   
             // com\\googlecode\\sparkleg\\Sparql.g:152:5: ( ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) )
 2817   
             // com\\googlecode\\sparkleg\\Sparql.g:152:7: ( WHERE )? groupGraphPattern
 2818  1356 
             {
 2819   
             // com\\googlecode\\sparkleg\\Sparql.g:152:7: ( WHERE )?
 2820  7250 
             int alt22=2;
 2821  7250 
             switch ( input.LA(1) ) {
 2822   
                 case WHERE:
 2823  1856 
                     {
 2824  6015 
                     alt22=1;
 2825   
                     }
 2826   
                     break;
 2827  1356 
             }
 2828  1356 
 
 2829  7250 
             switch (alt22) {
 2830   
                 case 1 :
 2831   
                     // com\\googlecode\\sparkleg\\Sparql.g:152:7: WHERE
 2832   
                     {
 2833  6015 
                     WHERE63=(Token)match(input,WHERE,FOLLOW_WHERE_in_whereClause872);
 2834  6015 
                     stream_WHERE.add(WHERE63);
 2835   
 
 2836   
 
 2837  1856 
                     }
 2838  1856 
                     break;
 2839   
 
 2840  1856 
             }
 2841   
 
 2842  1856 
 
 2843  7250 
             pushFollow(FOLLOW_groupGraphPattern_in_whereClause875);
 2844  7250 
             groupGraphPattern64=groupGraphPattern();
 2845   
 
 2846  7250 
             state._fsp--;
 2847   
 
 2848  7250 
             stream_groupGraphPattern.add(groupGraphPattern64.getTree());
 2849   
 
 2850   
             // AST REWRITE
 2851  1856 
             // elements: groupGraphPattern
 2852  1856 
             // token labels:
 2853   
             // rule labels: retval
 2854  1856 
             // token list labels:
 2855   
             // rule list labels:
 2856   
             // wildcard labels:
 2857  7250 
             retval.tree = root_0;
 2858  7250 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2859  1856 
 
 2860  9106 
             root_0 = (Object)adaptor.nil();
 2861   
             // 152:32: -> ^( WHERE_CLAUSE groupGraphPattern )
 2862   
             {
 2863   
                 // com\\googlecode\\sparkleg\\Sparql.g:152:35: ^( WHERE_CLAUSE groupGraphPattern )
 2864  1856 
                 {
 2865  7250 
                 Object root_1 = (Object)adaptor.nil();
 2866  9106 
                 root_1 = (Object)adaptor.becomeRoot(
 2867   
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2868   
                 , root_1);
 2869   
 
 2870  7250 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 2871   
 
 2872  9106 
                 adaptor.addChild(root_0, root_1);
 2873   
                 }
 2874   
 
 2875   
             }
 2876  1856 
 
 2877   
 
 2878  7250 
             retval.tree = root_0;
 2879  1856 
 
 2880  1856 
             }
 2881   
 
 2882  7250 
             retval.stop = input.LT(-1);
 2883   
 
 2884   
 
 2885  7250 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2886  7250 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2887   
 
 2888   
         }
 2889  0 
         catch (RecognitionException re) {
 2890  0 
             reportError(re);
 2891  0 
             recover(input,re);
 2892  1856 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2893  1856 
 
 2894   
         }
 2895   
 
 2896  0 
         finally {
 2897   
                 // do for sure before leaving
 2898  7250 
         }
 2899  7250 
         return retval;
 2900  1874 
     }
 2901   
     // $ANTLR end "whereClause"
 2902   
 
 2903   
 
 2904  7322 
     public static class solutionModifier_return extends ParserRuleReturnScope {
 2905   
         Object tree;
 2906  7322 
         public Object getTree() { return tree; }
 2907  1874 
     };
 2908  1874 
 
 2909   
 
 2910   
     // $ANTLR start "solutionModifier"
 2911  1874 
     // com\\googlecode\\sparkleg\\Sparql.g:155:1: solutionModifier : ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* ;
 2912   
     public final SparqlParser.solutionModifier_return solutionModifier() throws RecognitionException {
 2913  9196 
         SparqlParser.solutionModifier_return retval = new SparqlParser.solutionModifier_return();
 2914  7322 
         retval.start = input.LT(1);
 2915  1874 
 
 2916   
 
 2917  9196 
         Object root_0 = null;
 2918   
 
 2919  9196 
         SparqlParser.groupClause_return groupClause65 =null;
 2920   
 
 2921  7322 
         SparqlParser.havingClause_return havingClause66 =null;
 2922  1874 
 
 2923  9196 
         SparqlParser.orderClause_return orderClause67 =null;
 2924  1874 
 
 2925  9196 
         SparqlParser.limitOffsetClauses_return limitOffsetClauses68 =null;
 2926   
 
 2927   
 
 2928  7322 
         RewriteRuleSubtreeStream stream_limitOffsetClauses=new RewriteRuleSubtreeStream(adaptor,"rule limitOffsetClauses");
 2929  7322 
         RewriteRuleSubtreeStream stream_orderClause=new RewriteRuleSubtreeStream(adaptor,"rule orderClause");
 2930  7322 
         RewriteRuleSubtreeStream stream_groupClause=new RewriteRuleSubtreeStream(adaptor,"rule groupClause");
 2931  9196 
         RewriteRuleSubtreeStream stream_havingClause=new RewriteRuleSubtreeStream(adaptor,"rule havingClause");
 2932  1874 
         try {
 2933   
             // com\\googlecode\\sparkleg\\Sparql.g:156:5: ( ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* )
 2934   
             // com\\googlecode\\sparkleg\\Sparql.g:156:7: ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )?
 2935  66 
             {
 2936   
             // com\\googlecode\\sparkleg\\Sparql.g:156:7: ( groupClause )?
 2937  7322 
             int alt23=2;
 2938  7322 
             switch ( input.LA(1) ) {
 2939   
                 case GROUP:
 2940  1874 
                     {
 2941  264 
                     alt23=1;
 2942   
                     }
 2943   
                     break;
 2944  66 
             }
 2945  66 
 
 2946  7322 
             switch (alt23) {
 2947  66 
                 case 1 :
 2948   
                     // com\\googlecode\\sparkleg\\Sparql.g:156:7: groupClause
 2949  66 
                     {
 2950  264 
                     pushFollow(FOLLOW_groupClause_in_solutionModifier900);
 2951  264 
                     groupClause65=groupClause();
 2952   
 
 2953  264 
                     state._fsp--;
 2954   
 
 2955  264 
                     stream_groupClause.add(groupClause65.getTree());
 2956   
 
 2957   
                     }
 2958  1874 
                     break;
 2959  1874 
 
 2960   
             }
 2961   
 
 2962  16 
 
 2963   
             // com\\googlecode\\sparkleg\\Sparql.g:156:20: ( havingClause )?
 2964  7322 
             int alt24=2;
 2965  7322 
             switch ( input.LA(1) ) {
 2966   
                 case HAVING:
 2967  1874 
                     {
 2968  64 
                     alt24=1;
 2969   
                     }
 2970   
                     break;
 2971  16 
             }
 2972  16 
 
 2973  7322 
             switch (alt24) {
 2974  16 
                 case 1 :
 2975   
                     // com\\googlecode\\sparkleg\\Sparql.g:156:20: havingClause
 2976  16 
                     {
 2977  64 
                     pushFollow(FOLLOW_havingClause_in_solutionModifier903);
 2978  64 
                     havingClause66=havingClause();
 2979   
 
 2980  64 
                     state._fsp--;
 2981   
 
 2982  64 
                     stream_havingClause.add(havingClause66.getTree());
 2983   
 
 2984   
                     }
 2985  1874 
                     break;
 2986  1874 
 
 2987   
             }
 2988   
 
 2989  134 
 
 2990   
             // com\\googlecode\\sparkleg\\Sparql.g:156:34: ( orderClause )?
 2991  7322 
             int alt25=2;
 2992  7322 
             switch ( input.LA(1) ) {
 2993   
                 case ORDER:
 2994  1874 
                     {
 2995  536 
                     alt25=1;
 2996   
                     }
 2997   
                     break;
 2998  134 
             }
 2999  134 
 
 3000  7322 
             switch (alt25) {
 3001  134 
                 case 1 :
 3002   
                     // com\\googlecode\\sparkleg\\Sparql.g:156:34: orderClause
 3003  134 
                     {
 3004  536 
                     pushFollow(FOLLOW_orderClause_in_solutionModifier906);
 3005  536 
                     orderClause67=orderClause();
 3006   
 
 3007  536 
                     state._fsp--;
 3008   
 
 3009  536 
                     stream_orderClause.add(orderClause67.getTree());
 3010   
 
 3011   
                     }
 3012  1874 
                     break;
 3013  1874 
 
 3014   
             }
 3015   
 
 3016   
 
 3017  58 
             // com\\googlecode\\sparkleg\\Sparql.g:156:47: ( limitOffsetClauses )?
 3018  7322 
             int alt26=2;
 3019  7322 
             switch ( input.LA(1) ) {
 3020   
                 case LIMIT:
 3021   
                 case OFFSET:
 3022  1874 
                     {
 3023  232 
                     alt26=1;
 3024   
                     }
 3025   
                     break;
 3026  58 
             }
 3027  58 
 
 3028  7322 
             switch (alt26) {
 3029  58 
                 case 1 :
 3030   
                     // com\\googlecode\\sparkleg\\Sparql.g:156:47: limitOffsetClauses
 3031  58 
                     {
 3032  232 
                     pushFollow(FOLLOW_limitOffsetClauses_in_solutionModifier909);
 3033  232 
                     limitOffsetClauses68=limitOffsetClauses();
 3034   
 
 3035  232 
                     state._fsp--;
 3036   
 
 3037  232 
                     stream_limitOffsetClauses.add(limitOffsetClauses68.getTree());
 3038   
 
 3039   
                     }
 3040   
                     break;
 3041   
 
 3042   
             }
 3043   
 
 3044   
 
 3045   
             // AST REWRITE
 3046  1874 
             // elements: havingClause, limitOffsetClauses, groupClause, orderClause
 3047  1874 
             // token labels:
 3048   
             // rule labels: retval
 3049  1874 
             // token list labels:
 3050   
             // rule list labels:
 3051   
             // wildcard labels:
 3052  7322 
             retval.tree = root_0;
 3053  9262 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3054  66 
 
 3055  7322 
             root_0 = (Object)adaptor.nil();
 3056   
             // 156:67: -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )*
 3057  1874 
             {
 3058   
                 // com\\googlecode\\sparkleg\\Sparql.g:156:70: ( groupClause )*
 3059  7586 
                 while ( stream_groupClause.hasNext() ) {
 3060  2154 
                     adaptor.addChild(root_0, stream_groupClause.nextTree());
 3061  16 
 
 3062   
                 }
 3063  7322 
                 stream_groupClause.reset();
 3064  1874 
 
 3065   
                 // com\\googlecode\\sparkleg\\Sparql.g:156:83: ( havingClause )*
 3066  7386 
                 while ( stream_havingClause.hasNext() ) {
 3067  2072 
                     adaptor.addChild(root_0, stream_havingClause.nextTree());
 3068  134 
 
 3069   
                 }
 3070  7322 
                 stream_havingClause.reset();
 3071  1874 
 
 3072   
                 // com\\googlecode\\sparkleg\\Sparql.g:156:97: ( orderClause )*
 3073  7858 
                 while ( stream_orderClause.hasNext() ) {
 3074  2468 
                     adaptor.addChild(root_0, stream_orderClause.nextTree());
 3075  58 
 
 3076   
                 }
 3077  7322 
                 stream_orderClause.reset();
 3078  1874 
 
 3079   
                 // com\\googlecode\\sparkleg\\Sparql.g:156:110: ( limitOffsetClauses )*
 3080  7554 
                 while ( stream_limitOffsetClauses.hasNext() ) {
 3081  232 
                     adaptor.addChild(root_0, stream_limitOffsetClauses.nextTree());
 3082   
 
 3083  1874 
                 }
 3084  7322 
                 stream_limitOffsetClauses.reset();
 3085   
 
 3086   
             }
 3087  1874 
 
 3088   
 
 3089  7322 
             retval.tree = root_0;
 3090  1874 
 
 3091  1874 
             }
 3092   
 
 3093  7322 
             retval.stop = input.LT(-1);
 3094   
 
 3095   
 
 3096  7322 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3097  7322 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3098   
 
 3099   
         }
 3100  0 
         catch (RecognitionException re) {
 3101  0 
             reportError(re);
 3102  0 
             recover(input,re);
 3103  1874 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3104  1874 
 
 3105   
         }
 3106   
 
 3107  0 
         finally {
 3108   
                 // do for sure before leaving
 3109  66 
         }
 3110  7322 
         return retval;
 3111  66 
     }
 3112   
     // $ANTLR end "solutionModifier"
 3113   
 
 3114   
 
 3115  264 
     public static class groupClause_return extends ParserRuleReturnScope {
 3116   
         Object tree;
 3117  264 
         public Object getTree() { return tree; }
 3118  66 
     };
 3119  66 
 
 3120   
 
 3121   
     // $ANTLR start "groupClause"
 3122  66 
     // com\\googlecode\\sparkleg\\Sparql.g:159:1: groupClause : GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) ;
 3123   
     public final SparqlParser.groupClause_return groupClause() throws RecognitionException {
 3124  330 
         SparqlParser.groupClause_return retval = new SparqlParser.groupClause_return();
 3125  330 
         retval.start = input.LT(1);
 3126  66 
 
 3127   
 
 3128  264 
         Object root_0 = null;
 3129  66 
 
 3130  330 
         Token GROUP69=null;
 3131  330 
         Token BY70=null;
 3132  330 
         SparqlParser.groupCondition_return groupCondition71 =null;
 3133  66 
 
 3134   
 
 3135  264 
         Object GROUP69_tree=null;
 3136  264 
         Object BY70_tree=null;
 3137  264 
         RewriteRuleTokenStream stream_GROUP=new RewriteRuleTokenStream(adaptor,"token GROUP");
 3138  330 
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3139  330 
         RewriteRuleSubtreeStream stream_groupCondition=new RewriteRuleSubtreeStream(adaptor,"rule groupCondition");
 3140   
         try {
 3141   
             // com\\googlecode\\sparkleg\\Sparql.g:160:5: ( GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) )
 3142  66 
             // com\\googlecode\\sparkleg\\Sparql.g:160:7: GROUP BY ( groupCondition )+
 3143  66 
             {
 3144  264 
             GROUP69=(Token)match(input,GROUP,FOLLOW_GROUP_in_groupClause941);
 3145  264 
             stream_GROUP.add(GROUP69);
 3146   
 
 3147  66 
 
 3148  264 
             BY70=(Token)match(input,BY,FOLLOW_BY_in_groupClause943);
 3149  264 
             stream_BY.add(BY70);
 3150  136 
 
 3151  136 
 
 3152   
             // com\\googlecode\\sparkleg\\Sparql.g:160:16: ( groupCondition )+
 3153  264 
             int cnt27=0;
 3154   
             loop27:
 3155   
             do {
 3156  544 
                 int alt27=2;
 3157  544 
                 switch ( input.LA(1) ) {
 3158   
                 case ABS:
 3159   
                 case BNODE:
 3160   
                 case BOUND:
 3161   
                 case CEIL:
 3162   
                 case COALESCE:
 3163   
                 case CONCAT:
 3164   
                 case CONTAINS:
 3165   
                 case DATATYPE:
 3166   
                 case DAY:
 3167   
                 case ENCODE_FOR_URI:
 3168   
                 case EXISTS:
 3169   
                 case FLOOR:
 3170   
                 case HOURS:
 3171   
                 case IF:
 3172   
                 case IRI:
 3173   
                 case IRI_REF:
 3174   
                 case ISBLANK:
 3175   
                 case ISIRI:
 3176   
                 case ISLITERAL:
 3177   
                 case ISNUMERIC:
 3178   
                 case ISURI:
 3179   
                 case LANG:
 3180   
                 case LANGMATCHES:
 3181   
                 case LCASE:
 3182   
                 case MD5:
 3183   
                 case MINUTES:
 3184   
                 case MONTH:
 3185   
                 case NOT:
 3186   
                 case NOW:
 3187   
                 case PNAME_LN:
 3188   
                 case PNAME_NS:
 3189   
                 case RAND:
 3190   
                 case REGEX:
 3191   
                 case REPLACE:
 3192   
                 case ROUND:
 3193   
                 case SAMETERM:
 3194   
                 case SECONDS:
 3195   
                 case SHA1:
 3196   
                 case SHA256:
 3197   
                 case SHA384:
 3198   
                 case SHA512:
 3199   
                 case STR:
 3200   
                 case STRAFTER:
 3201   
                 case STRBEFORE:
 3202   
                 case STRDT:
 3203   
                 case STRENDS:
 3204   
                 case STRLANG:
 3205   
                 case STRLEN:
 3206   
                 case STRSTARTS:
 3207   
                 case SUBSTR:
 3208   
                 case TIMEZONE:
 3209   
                 case TZ:
 3210   
                 case UCASE:
 3211  70 
                 case URI:
 3212   
                 case VAR1:
 3213   
                 case VAR2:
 3214   
                 case YEAR:
 3215   
                 case 209:
 3216   
                     {
 3217  416 
                     alt27=1;
 3218   
                     }
 3219   
                     break;
 3220   
 
 3221  70 
                 }
 3222  70 
 
 3223  544 
                 switch (alt27) {
 3224  70 
                     case 1 :
 3225   
                         // com\\googlecode\\sparkleg\\Sparql.g:160:16: groupCondition
 3226  70 
                         {
 3227  280 
                         pushFollow(FOLLOW_groupCondition_in_groupClause945);
 3228  280 
                         groupCondition71=groupCondition();
 3229  70 
 
 3230  280 
                         state._fsp--;
 3231   
 
 3232  346 
                         stream_groupCondition.add(groupCondition71.getTree());
 3233   
 
 3234   
                         }
 3235  280 
                         break;
 3236   
 
 3237  70 
                     default :
 3238  334 
                         if ( cnt27 >= 1 ) break loop27;
 3239  0 
                         EarlyExitException eee =
 3240   
                             new EarlyExitException(27, input);
 3241  0 
                         throw eee;
 3242   
                 }
 3243  280 
                 cnt27++;
 3244  280 
             } while (true);
 3245   
 
 3246   
 
 3247   
             // AST REWRITE
 3248  66 
             // elements: groupCondition
 3249  66 
             // token labels:
 3250   
             // rule labels: retval
 3251  66 
             // token list labels:
 3252   
             // rule list labels:
 3253   
             // wildcard labels:
 3254  264 
             retval.tree = root_0;
 3255  264 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3256  66 
 
 3257  330 
             root_0 = (Object)adaptor.nil();
 3258   
             // 160:32: -> ^( GROUP_BY ( groupCondition )+ )
 3259   
             {
 3260   
                 // com\\googlecode\\sparkleg\\Sparql.g:160:35: ^( GROUP_BY ( groupCondition )+ )
 3261  66 
                 {
 3262  264 
                 Object root_1 = (Object)adaptor.nil();
 3263  264 
                 root_1 = (Object)adaptor.becomeRoot(
 3264  136 
                 (Object)adaptor.create(GROUP_BY, "GROUP_BY")
 3265  70 
                 , root_1);
 3266   
 
 3267  264 
                 if ( !(stream_groupCondition.hasNext()) ) {
 3268  66 
                     throw new RewriteEarlyExitException();
 3269   
                 }
 3270  610 
                 while ( stream_groupCondition.hasNext() ) {
 3271  280 
                     adaptor.addChild(root_1, stream_groupCondition.nextTree());
 3272   
 
 3273   
                 }
 3274  264 
                 stream_groupCondition.reset();
 3275   
 
 3276  330 
                 adaptor.addChild(root_0, root_1);
 3277   
                 }
 3278   
 
 3279   
             }
 3280  66 
 
 3281   
 
 3282  264 
             retval.tree = root_0;
 3283  66 
 
 3284  66 
             }
 3285   
 
 3286  264 
             retval.stop = input.LT(-1);
 3287   
 
 3288   
 
 3289  264 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3290  264 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3291   
 
 3292   
         }
 3293  0 
         catch (RecognitionException re) {
 3294  0 
             reportError(re);
 3295  0 
             recover(input,re);
 3296  66 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3297  66 
 
 3298   
         }
 3299   
 
 3300  0 
         finally {
 3301   
                 // do for sure before leaving
 3302  264 
         }
 3303  264 
         return retval;
 3304  70 
     }
 3305   
     // $ANTLR end "groupClause"
 3306   
 
 3307   
 
 3308  280 
     public static class groupCondition_return extends ParserRuleReturnScope {
 3309   
         Object tree;
 3310  280 
         public Object getTree() { return tree; }
 3311  70 
     };
 3312  70 
 
 3313   
 
 3314   
     // $ANTLR start "groupCondition"
 3315  70 
     // com\\googlecode\\sparkleg\\Sparql.g:163:1: groupCondition : ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | '(' expression ( AS var )? ')' -> ^( GROUP_CONDITION expression ( var )? ) | var -> ^( GROUP_CONDITION var ) );
 3316   
     public final SparqlParser.groupCondition_return groupCondition() throws RecognitionException {
 3317  350 
         SparqlParser.groupCondition_return retval = new SparqlParser.groupCondition_return();
 3318  350 
         retval.start = input.LT(1);
 3319  70 
 
 3320  70 
 
 3321  280 
         Object root_0 = null;
 3322  70 
 
 3323  280 
         Token char_literal74=null;
 3324  350 
         Token AS76=null;
 3325  280 
         Token char_literal78=null;
 3326  350 
         SparqlParser.builtInCall_return builtInCall72 =null;
 3327   
 
 3328  350 
         SparqlParser.functionCall_return functionCall73 =null;
 3329   
 
 3330  280 
         SparqlParser.expression_return expression75 =null;
 3331  70 
 
 3332  350 
         SparqlParser.var_return var77 =null;
 3333  70 
 
 3334  350 
         SparqlParser.var_return var79 =null;
 3335  70 
 
 3336  70 
 
 3337  350 
         Object char_literal74_tree=null;
 3338  350 
         Object AS76_tree=null;
 3339  350 
         Object char_literal78_tree=null;
 3340  350 
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 3341  280 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 3342  280 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 3343  350 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 3344  350 
         RewriteRuleSubtreeStream stream_functionCall=new RewriteRuleSubtreeStream(adaptor,"rule functionCall");
 3345  280 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 3346  280 
         RewriteRuleSubtreeStream stream_builtInCall=new RewriteRuleSubtreeStream(adaptor,"rule builtInCall");
 3347   
         try {
 3348   
             // com\\googlecode\\sparkleg\\Sparql.g:164:5: ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | '(' expression ( AS var )? ')' -> ^( GROUP_CONDITION expression ( var )? ) | var -> ^( GROUP_CONDITION var ) )
 3349  280 
             int alt29=4;
 3350  280 
             switch ( input.LA(1) ) {
 3351   
             case ABS:
 3352   
             case BNODE:
 3353   
             case BOUND:
 3354   
             case CEIL:
 3355   
             case COALESCE:
 3356   
             case CONCAT:
 3357   
             case CONTAINS:
 3358   
             case DATATYPE:
 3359   
             case DAY:
 3360   
             case ENCODE_FOR_URI:
 3361   
             case EXISTS:
 3362   
             case FLOOR:
 3363   
             case HOURS:
 3364   
             case IF:
 3365   
             case IRI:
 3366   
             case ISBLANK:
 3367   
             case ISIRI:
 3368   
             case ISLITERAL:
 3369   
             case ISNUMERIC:
 3370   
             case ISURI:
 3371   
             case LANG:
 3372   
             case LANGMATCHES:
 3373   
             case LCASE:
 3374   
             case MD5:
 3375   
             case MINUTES:
 3376   
             case MONTH:
 3377   
             case NOT:
 3378   
             case NOW:
 3379   
             case RAND:
 3380   
             case REGEX:
 3381   
             case REPLACE:
 3382   
             case ROUND:
 3383   
             case SAMETERM:
 3384   
             case SECONDS:
 3385   
             case SHA1:
 3386   
             case SHA256:
 3387   
             case SHA384:
 3388   
             case SHA512:
 3389   
             case STR:
 3390   
             case STRAFTER:
 3391   
             case STRBEFORE:
 3392   
             case STRDT:
 3393   
             case STRENDS:
 3394   
             case STRLANG:
 3395   
             case STRLEN:
 3396   
             case STRSTARTS:
 3397   
             case SUBSTR:
 3398   
             case TIMEZONE:
 3399   
             case TZ:
 3400   
             case UCASE:
 3401   
             case URI:
 3402   
             case YEAR:
 3403   
                 {
 3404  0 
                 alt29=1;
 3405   
                 }
 3406  0 
                 break;
 3407   
             case IRI_REF:
 3408   
             case PNAME_LN:
 3409   
             case PNAME_NS:
 3410  12 
                 {
 3411  0 
                 alt29=2;
 3412  12 
                 }
 3413  0 
                 break;
 3414   
             case 209:
 3415   
                 {
 3416  106 
                 alt29=3;
 3417   
                 }
 3418  106 
                 break;
 3419   
             case VAR1:
 3420   
             case VAR2:
 3421   
                 {
 3422  232 
                 alt29=4;
 3423   
                 }
 3424  232 
                 break;
 3425   
             default:
 3426  0 
                 NoViableAltException nvae =
 3427  70 
                     new NoViableAltException("", 29, 0, input);
 3428   
 
 3429  0 
                 throw nvae;
 3430   
 
 3431   
             }
 3432   
 
 3433  280 
             switch (alt29) {
 3434   
                 case 1 :
 3435   
                     // com\\googlecode\\sparkleg\\Sparql.g:164:7: builtInCall
 3436   
                     {
 3437  0 
                     pushFollow(FOLLOW_builtInCall_in_groupCondition979);
 3438  0 
                     builtInCall72=builtInCall();
 3439   
 
 3440  0 
                     state._fsp--;
 3441   
 
 3442  0 
                     stream_builtInCall.add(builtInCall72.getTree());
 3443   
 
 3444   
                     // AST REWRITE
 3445   
                     // elements: builtInCall
 3446   
                     // token labels:
 3447   
                     // rule labels: retval
 3448   
                     // token list labels:
 3449   
                     // rule list labels:
 3450   
                     // wildcard labels:
 3451  0 
                     retval.tree = root_0;
 3452  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3453   
 
 3454  0 
                     root_0 = (Object)adaptor.nil();
 3455   
                     // 164:19: -> ^( GROUP_CONDITION builtInCall )
 3456   
                     {
 3457   
                         // com\\googlecode\\sparkleg\\Sparql.g:164:22: ^( GROUP_CONDITION builtInCall )
 3458   
                         {
 3459  0 
                         Object root_1 = (Object)adaptor.nil();
 3460  0 
                         root_1 = (Object)adaptor.becomeRoot(
 3461   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3462   
                         , root_1);
 3463   
 
 3464  0 
                         adaptor.addChild(root_1, stream_builtInCall.nextTree());
 3465   
 
 3466  0 
                         adaptor.addChild(root_0, root_1);
 3467   
                         }
 3468   
 
 3469   
                     }
 3470   
 
 3471   
 
 3472  0 
                     retval.tree = root_0;
 3473   
 
 3474   
                     }
 3475  0 
                     break;
 3476   
                 case 2 :
 3477   
                     // com\\googlecode\\sparkleg\\Sparql.g:165:7: functionCall
 3478   
                     {
 3479  0 
                     pushFollow(FOLLOW_functionCall_in_groupCondition995);
 3480  0 
                     functionCall73=functionCall();
 3481   
 
 3482  0 
                     state._fsp--;
 3483   
 
 3484  0 
                     stream_functionCall.add(functionCall73.getTree());
 3485   
 
 3486   
                     // AST REWRITE
 3487   
                     // elements: functionCall
 3488   
                     // token labels:
 3489   
                     // rule labels: retval
 3490   
                     // token list labels:
 3491   
                     // rule list labels:
 3492   
                     // wildcard labels:
 3493  0 
                     retval.tree = root_0;
 3494  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3495   
 
 3496  0 
                     root_0 = (Object)adaptor.nil();
 3497   
                     // 165:20: -> ^( GROUP_CONDITION functionCall )
 3498   
                     {
 3499   
                         // com\\googlecode\\sparkleg\\Sparql.g:165:23: ^( GROUP_CONDITION functionCall )
 3500   
                         {
 3501  0 
                         Object root_1 = (Object)adaptor.nil();
 3502  0 
                         root_1 = (Object)adaptor.becomeRoot(
 3503   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3504   
                         , root_1);
 3505   
 
 3506  0 
                         adaptor.addChild(root_1, stream_functionCall.nextTree());
 3507   
 
 3508  0 
                         adaptor.addChild(root_0, root_1);
 3509   
                         }
 3510   
 
 3511   
                     }
 3512   
 
 3513   
 
 3514  0 
                     retval.tree = root_0;
 3515  12 
 
 3516  12 
                     }
 3517  0 
                     break;
 3518   
                 case 3 :
 3519  12 
                     // com\\googlecode\\sparkleg\\Sparql.g:166:7: '(' expression ( AS var )? ')'
 3520  12 
                     {
 3521  48 
                     char_literal74=(Token)match(input,209,FOLLOW_209_in_groupCondition1011);
 3522  60 
                     stream_209.add(char_literal74);
 3523   
 
 3524  12 
 
 3525  48 
                     pushFollow(FOLLOW_expression_in_groupCondition1013);
 3526  48 
                     expression75=expression();
 3527  12 
 
 3528  60 
                     state._fsp--;
 3529   
 
 3530  48 
                     stream_expression.add(expression75.getTree());
 3531  4 
 
 3532   
                     // com\\googlecode\\sparkleg\\Sparql.g:166:22: ( AS var )?
 3533  48 
                     int alt28=2;
 3534  48 
                     switch ( input.LA(1) ) {
 3535   
                         case AS:
 3536  12 
                             {
 3537  16 
                             alt28=1;
 3538   
                             }
 3539   
                             break;
 3540  4 
                     }
 3541  4 
 
 3542  48 
                     switch (alt28) {
 3543   
                         case 1 :
 3544  4 
                             // com\\googlecode\\sparkleg\\Sparql.g:166:23: AS var
 3545  4 
                             {
 3546  16 
                             AS76=(Token)match(input,AS,FOLLOW_AS_in_groupCondition1016);
 3547  20 
                             stream_AS.add(AS76);
 3548   
 
 3549  4 
 
 3550  16 
                             pushFollow(FOLLOW_var_in_groupCondition1018);
 3551  16 
                             var77=var();
 3552   
 
 3553  16 
                             state._fsp--;
 3554   
 
 3555  16 
                             stream_var.add(var77.getTree());
 3556   
 
 3557  12 
                             }
 3558  12 
                             break;
 3559   
 
 3560   
                     }
 3561   
 
 3562   
 
 3563  48 
                     char_literal78=(Token)match(input,210,FOLLOW_210_in_groupCondition1022);
 3564  48 
                     stream_210.add(char_literal78);
 3565   
 
 3566   
 
 3567   
                     // AST REWRITE
 3568  12 
                     // elements: var, expression
 3569  12 
                     // token labels:
 3570   
                     // rule labels: retval
 3571  12 
                     // token list labels:
 3572   
                     // rule list labels:
 3573   
                     // wildcard labels:
 3574  48 
                     retval.tree = root_0;
 3575  48 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3576  12 
 
 3577  60 
                     root_0 = (Object)adaptor.nil();
 3578   
                     // 166:36: -> ^( GROUP_CONDITION expression ( var )? )
 3579   
                     {
 3580   
                         // com\\googlecode\\sparkleg\\Sparql.g:166:39: ^( GROUP_CONDITION expression ( var )? )
 3581  12 
                         {
 3582  48 
                         Object root_1 = (Object)adaptor.nil();
 3583  48 
                         root_1 = (Object)adaptor.becomeRoot(
 3584  12 
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3585   
                         , root_1);
 3586   
 
 3587  52 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 3588  4 
 
 3589   
                         // com\\googlecode\\sparkleg\\Sparql.g:166:68: ( var )?
 3590  48 
                         if ( stream_var.hasNext() ) {
 3591  16 
                             adaptor.addChild(root_1, stream_var.nextTree());
 3592  4 
 
 3593   
                         }
 3594  52 
                         stream_var.reset();
 3595   
 
 3596  48 
                         adaptor.addChild(root_0, root_1);
 3597   
                         }
 3598  12 
 
 3599  12 
                     }
 3600   
 
 3601  12 
 
 3602  48 
                     retval.tree = root_0;
 3603   
 
 3604   
                     }
 3605  48 
                     break;
 3606   
                 case 4 :
 3607  12 
                     // com\\googlecode\\sparkleg\\Sparql.g:167:7: var
 3608   
                     {
 3609  232 
                     pushFollow(FOLLOW_var_in_groupCondition1041);
 3610  244 
                     var79=var();
 3611   
 
 3612  232 
                     state._fsp--;
 3613   
 
 3614  290 
                     stream_var.add(var79.getTree());
 3615  58 
 
 3616   
                     // AST REWRITE
 3617  58 
                     // elements: var
 3618   
                     // token labels:
 3619  58 
                     // rule labels: retval
 3620   
                     // token list labels:
 3621   
                     // rule list labels:
 3622   
                     // wildcard labels:
 3623  232 
                     retval.tree = root_0;
 3624  232 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3625   
 
 3626  232 
                     root_0 = (Object)adaptor.nil();
 3627   
                     // 167:11: -> ^( GROUP_CONDITION var )
 3628  58 
                     {
 3629  58 
                         // com\\googlecode\\sparkleg\\Sparql.g:167:14: ^( GROUP_CONDITION var )
 3630   
                         {
 3631  290 
                         Object root_1 = (Object)adaptor.nil();
 3632  232 
                         root_1 = (Object)adaptor.becomeRoot(
 3633   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3634   
                         , root_1);
 3635   
 
 3636  290 
                         adaptor.addChild(root_1, stream_var.nextTree());
 3637  58 
 
 3638  232 
                         adaptor.addChild(root_0, root_1);
 3639   
                         }
 3640   
 
 3641  58 
                     }
 3642   
 
 3643  58 
 
 3644  232 
                     retval.tree = root_0;
 3645   
 
 3646   
                     }
 3647   
                     break;
 3648   
 
 3649  58 
             }
 3650  280 
             retval.stop = input.LT(-1);
 3651   
 
 3652   
 
 3653  280 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3654  280 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3655  70 
 
 3656   
         }
 3657  0 
         catch (RecognitionException re) {
 3658  70 
             reportError(re);
 3659  70 
             recover(input,re);
 3660  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3661   
 
 3662   
         }
 3663   
 
 3664  0 
         finally {
 3665   
                 // do for sure before leaving
 3666  280 
         }
 3667  280 
         return retval;
 3668   
     }
 3669   
     // $ANTLR end "groupCondition"
 3670   
 
 3671  70 
 
 3672  70 
     public static class havingClause_return extends ParserRuleReturnScope {
 3673   
         Object tree;
 3674  64 
         public Object getTree() { return tree; }
 3675   
     };
 3676   
 
 3677  16 
 
 3678   
     // $ANTLR start "havingClause"
 3679  16 
     // com\\googlecode\\sparkleg\\Sparql.g:170:1: havingClause : HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) ;
 3680   
     public final SparqlParser.havingClause_return havingClause() throws RecognitionException {
 3681  64 
         SparqlParser.havingClause_return retval = new SparqlParser.havingClause_return();
 3682  64 
         retval.start = input.LT(1);
 3683   
 
 3684   
 
 3685  64 
         Object root_0 = null;
 3686  16 
 
 3687  80 
         Token HAVING80=null;
 3688  64 
         SparqlParser.constraint_return constraint81 =null;
 3689   
 
 3690  16 
 
 3691  64 
         Object HAVING80_tree=null;
 3692  80 
         RewriteRuleTokenStream stream_HAVING=new RewriteRuleTokenStream(adaptor,"token HAVING");
 3693  80 
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 3694   
         try {
 3695   
             // com\\googlecode\\sparkleg\\Sparql.g:171:5: ( HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) )
 3696  16 
             // com\\googlecode\\sparkleg\\Sparql.g:171:7: HAVING ( constraint )+
 3697  16 
             {
 3698  80 
             HAVING80=(Token)match(input,HAVING,FOLLOW_HAVING_in_havingClause1070);
 3699  64 
             stream_HAVING.add(HAVING80);
 3700   
 
 3701   
 
 3702   
             // com\\googlecode\\sparkleg\\Sparql.g:171:14: ( constraint )+
 3703  80 
             int cnt30=0;
 3704  16 
             loop30:
 3705   
             do {
 3706  128 
                 int alt30=2;
 3707  128 
                 switch ( input.LA(1) ) {
 3708  16 
                 case ABS:
 3709   
                 case BNODE:
 3710   
                 case BOUND:
 3711  32 
                 case CEIL:
 3712  32 
                 case COALESCE:
 3713   
                 case CONCAT:
 3714   
                 case CONTAINS:
 3715   
                 case DATATYPE:
 3716   
                 case DAY:
 3717   
                 case ENCODE_FOR_URI:
 3718   
                 case EXISTS:
 3719   
                 case FLOOR:
 3720   
                 case HOURS:
 3721   
                 case IF:
 3722   
                 case IRI:
 3723   
                 case IRI_REF:
 3724   
                 case ISBLANK:
 3725   
                 case ISIRI:
 3726   
                 case ISLITERAL:
 3727   
                 case ISNUMERIC:
 3728   
                 case ISURI:
 3729   
                 case LANG:
 3730   
                 case LANGMATCHES:
 3731   
                 case LCASE:
 3732   
                 case MD5:
 3733   
                 case MINUTES:
 3734   
                 case MONTH:
 3735   
                 case NOT:
 3736   
                 case NOW:
 3737   
                 case PNAME_LN:
 3738   
                 case PNAME_NS:
 3739   
                 case RAND:
 3740   
                 case REGEX:
 3741   
                 case REPLACE:
 3742   
                 case ROUND:
 3743   
                 case SAMETERM:
 3744   
                 case SECONDS:
 3745   
                 case SHA1:
 3746   
                 case SHA256:
 3747   
                 case SHA384:
 3748   
                 case SHA512:
 3749   
                 case STR:
 3750   
                 case STRAFTER:
 3751   
                 case STRBEFORE:
 3752   
                 case STRDT:
 3753   
                 case STRENDS:
 3754   
                 case STRLANG:
 3755   
                 case STRLEN:
 3756   
                 case STRSTARTS:
 3757   
                 case SUBSTR:
 3758   
                 case TIMEZONE:
 3759   
                 case TZ:
 3760   
                 case UCASE:
 3761   
                 case URI:
 3762   
                 case YEAR:
 3763   
                 case 209:
 3764   
                     {
 3765  64 
                     alt30=1;
 3766   
                     }
 3767   
                     break;
 3768   
 
 3769   
                 }
 3770  16 
 
 3771  128 
                 switch (alt30) {
 3772   
                     case 1 :
 3773   
                         // com\\googlecode\\sparkleg\\Sparql.g:171:14: constraint
 3774   
                         {
 3775  64 
                         pushFollow(FOLLOW_constraint_in_havingClause1072);
 3776  96 
                         constraint81=constraint();
 3777   
 
 3778  64 
                         state._fsp--;
 3779   
 
 3780  80 
                         stream_constraint.add(constraint81.getTree());
 3781  16 
 
 3782   
                         }
 3783  80 
                         break;
 3784   
 
 3785  16 
                     default :
 3786  64 
                         if ( cnt30 >= 1 ) break loop30;
 3787  0 
                         EarlyExitException eee =
 3788  16 
                             new EarlyExitException(30, input);
 3789  0 
                         throw eee;
 3790   
                 }
 3791  80 
                 cnt30++;
 3792  64 
             } while (true);
 3793   
 
 3794   
 
 3795   
             // AST REWRITE
 3796  16 
             // elements: HAVING, constraint
 3797  16 
             // token labels:
 3798   
             // rule labels: retval
 3799   
             // token list labels:
 3800   
             // rule list labels:
 3801   
             // wildcard labels:
 3802  64 
             retval.tree = root_0;
 3803  64 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3804   
 
 3805  64 
             root_0 = (Object)adaptor.nil();
 3806   
             // 171:26: -> ^( HAVING ( constraint )+ )
 3807  16 
             {
 3808  16 
                 // com\\googlecode\\sparkleg\\Sparql.g:171:29: ^( HAVING ( constraint )+ )
 3809   
                 {
 3810  80 
                 Object root_1 = (Object)adaptor.nil();
 3811  64 
                 root_1 = (Object)adaptor.becomeRoot(
 3812   
                 stream_HAVING.nextNode()
 3813   
                 , root_1);
 3814   
 
 3815  80 
                 if ( !(stream_constraint.hasNext()) ) {
 3816  16 
                     throw new RewriteEarlyExitException();
 3817   
                 }
 3818  128 
                 while ( stream_constraint.hasNext() ) {
 3819  64 
                     adaptor.addChild(root_1, stream_constraint.nextTree());
 3820  16 
 
 3821   
                 }
 3822  64 
                 stream_constraint.reset();
 3823  32 
 
 3824  80 
                 adaptor.addChild(root_0, root_1);
 3825   
                 }
 3826   
 
 3827  16 
             }
 3828   
 
 3829  16 
 
 3830  64 
             retval.tree = root_0;
 3831   
 
 3832   
             }
 3833   
 
 3834  64 
             retval.stop = input.LT(-1);
 3835  16 
 
 3836   
 
 3837  64 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3838  64 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3839  16 
 
 3840   
         }
 3841  0 
         catch (RecognitionException re) {
 3842  16 
             reportError(re);
 3843  16 
             recover(input,re);
 3844  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3845   
 
 3846   
         }
 3847   
 
 3848  0 
         finally {
 3849   
                 // do for sure before leaving
 3850  64 
         }
 3851  64 
         return retval;
 3852   
     }
 3853   
     // $ANTLR end "havingClause"
 3854   
 
 3855  16 
 
 3856  16 
     public static class orderClause_return extends ParserRuleReturnScope {
 3857   
         Object tree;
 3858  536 
         public Object getTree() { return tree; }
 3859   
     };
 3860   
 
 3861  134 
 
 3862   
     // $ANTLR start "orderClause"
 3863  134 
     // com\\googlecode\\sparkleg\\Sparql.g:174:1: orderClause : ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) ;
 3864   
     public final SparqlParser.orderClause_return orderClause() throws RecognitionException {
 3865  536 
         SparqlParser.orderClause_return retval = new SparqlParser.orderClause_return();
 3866  536 
         retval.start = input.LT(1);
 3867   
 
 3868   
 
 3869  536 
         Object root_0 = null;
 3870  134 
 
 3871  670 
         Token ORDER82=null;
 3872  536 
         Token BY83=null;
 3873  536 
         SparqlParser.orderCondition_return orderCondition84 =null;
 3874  134 
 
 3875   
 
 3876  670 
         Object ORDER82_tree=null;
 3877  670 
         Object BY83_tree=null;
 3878  670 
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3879  536 
         RewriteRuleTokenStream stream_ORDER=new RewriteRuleTokenStream(adaptor,"token ORDER");
 3880  536 
         RewriteRuleSubtreeStream stream_orderCondition=new RewriteRuleSubtreeStream(adaptor,"rule orderCondition");
 3881  134 
         try {
 3882  134 
             // com\\googlecode\\sparkleg\\Sparql.g:175:5: ( ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) )
 3883  134 
             // com\\googlecode\\sparkleg\\Sparql.g:175:7: ORDER BY ( orderCondition )+
 3884  134 
             {
 3885  670 
             ORDER82=(Token)match(input,ORDER,FOLLOW_ORDER_in_orderClause1104);
 3886  536 
             stream_ORDER.add(ORDER82);
 3887   
 
 3888   
 
 3889  536 
             BY83=(Token)match(input,BY,FOLLOW_BY_in_orderClause1106);
 3890  670 
             stream_BY.add(BY83);
 3891  134 
 
 3892   
 
 3893   
             // com\\googlecode\\sparkleg\\Sparql.g:175:16: ( orderCondition )+
 3894  670 
             int cnt31=0;
 3895  134 
             loop31:
 3896   
             do {
 3897  1264 
                 int alt31=2;
 3898  1264 
                 switch ( input.LA(1) ) {
 3899  134 
                 case ABS:
 3900   
                 case ASC:
 3901   
                 case BNODE:
 3902  316 
                 case BOUND:
 3903  316 
                 case CEIL:
 3904   
                 case COALESCE:
 3905   
                 case CONCAT:
 3906   
                 case CONTAINS:
 3907   
                 case DATATYPE:
 3908   
                 case DAY:
 3909   
                 case DESC:
 3910   
                 case ENCODE_FOR_URI:
 3911   
                 case EXISTS:
 3912   
                 case FLOOR:
 3913   
                 case HOURS:
 3914   
                 case IF:
 3915   
                 case IRI:
 3916   
                 case IRI_REF:
 3917   
                 case ISBLANK:
 3918   
                 case ISIRI:
 3919   
                 case ISLITERAL:
 3920   
                 case ISNUMERIC:
 3921   
                 case ISURI:
 3922   
                 case LANG:
 3923   
                 case LANGMATCHES:
 3924   
                 case LCASE:
 3925   
                 case MD5:
 3926   
                 case MINUTES:
 3927   
                 case MONTH:
 3928   
                 case NOT:
 3929   
                 case NOW:
 3930   
                 case PNAME_LN:
 3931   
                 case PNAME_NS:
 3932   
                 case RAND:
 3933   
                 case REGEX:
 3934   
                 case REPLACE:
 3935   
                 case ROUND:
 3936   
                 case SAMETERM:
 3937   
                 case SECONDS:
 3938   
                 case SHA1:
 3939   
                 case SHA256:
 3940   
                 case SHA384:
 3941   
                 case SHA512:
 3942   
                 case STR:
 3943   
                 case STRAFTER:
 3944   
                 case STRBEFORE:
 3945   
                 case STRDT:
 3946   
                 case STRENDS:
 3947   
                 case STRLANG:
 3948   
                 case STRLEN:
 3949   
                 case STRSTARTS:
 3950   
                 case SUBSTR:
 3951   
                 case TIMEZONE:
 3952   
                 case TZ:
 3953   
                 case UCASE:
 3954   
                 case URI:
 3955   
                 case VAR1:
 3956   
                 case VAR2:
 3957   
                 case YEAR:
 3958   
                 case 209:
 3959   
                     {
 3960  728 
                     alt31=1;
 3961   
                     }
 3962   
                     break;
 3963   
 
 3964   
                 }
 3965  182 
 
 3966  1264 
                 switch (alt31) {
 3967   
                     case 1 :
 3968   
                         // com\\googlecode\\sparkleg\\Sparql.g:175:16: orderCondition
 3969   
                         {
 3970  728 
                         pushFollow(FOLLOW_orderCondition_in_orderClause1108);
 3971  1044 
                         orderCondition84=orderCondition();
 3972   
 
 3973  728 
                         state._fsp--;
 3974   
 
 3975  910 
                         stream_orderCondition.add(orderCondition84.getTree());
 3976  182 
 
 3977   
                         }
 3978  910 
                         break;
 3979   
 
 3980  182 
                     default :
 3981  536 
                         if ( cnt31 >= 1 ) break loop31;
 3982  0 
                         EarlyExitException eee =
 3983  182 
                             new EarlyExitException(31, input);
 3984  0 
                         throw eee;
 3985   
                 }
 3986  862 
                 cnt31++;
 3987  728 
             } while (true);
 3988   
 
 3989   
 
 3990   
             // AST REWRITE
 3991  182 
             // elements: orderCondition
 3992  182 
             // token labels:
 3993   
             // rule labels: retval
 3994   
             // token list labels:
 3995   
             // rule list labels:
 3996   
             // wildcard labels:
 3997  536 
             retval.tree = root_0;
 3998  536 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3999   
 
 4000  536 
             root_0 = (Object)adaptor.nil();
 4001   
             // 175:32: -> ^( ORDER_BY ( orderCondition )+ )
 4002  134 
             {
 4003  134 
                 // com\\googlecode\\sparkleg\\Sparql.g:175:35: ^( ORDER_BY ( orderCondition )+ )
 4004   
                 {
 4005  670 
                 Object root_1 = (Object)adaptor.nil();
 4006  536 
                 root_1 = (Object)adaptor.becomeRoot(
 4007   
                 (Object)adaptor.create(ORDER_BY, "ORDER_BY")
 4008   
                 , root_1);
 4009   
 
 4010  670 
                 if ( !(stream_orderCondition.hasNext()) ) {
 4011  134 
                     throw new RewriteEarlyExitException();
 4012   
                 }
 4013  1264 
                 while ( stream_orderCondition.hasNext() ) {
 4014  728 
                     adaptor.addChild(root_1, stream_orderCondition.nextTree());
 4015  134 
 
 4016   
                 }
 4017  536 
                 stream_orderCondition.reset();
 4018  316 
 
 4019  718 
                 adaptor.addChild(root_0, root_1);
 4020   
                 }
 4021   
 
 4022  134 
             }
 4023   
 
 4024  134 
 
 4025  536 
             retval.tree = root_0;
 4026   
 
 4027   
             }
 4028   
 
 4029  536 
             retval.stop = input.LT(-1);
 4030  134 
 
 4031   
 
 4032  536 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4033  536 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4034  134 
 
 4035   
         }
 4036  0 
         catch (RecognitionException re) {
 4037  134 
             reportError(re);
 4038  134 
             recover(input,re);
 4039  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4040   
 
 4041   
         }
 4042   
 
 4043  0 
         finally {
 4044   
                 // do for sure before leaving
 4045  536 
         }
 4046  536 
         return retval;
 4047   
     }
 4048   
     // $ANTLR end "orderClause"
 4049   
 
 4050  134 
 
 4051  134 
     public static class orderCondition_return extends ParserRuleReturnScope {
 4052   
         Object tree;
 4053  728 
         public Object getTree() { return tree; }
 4054   
     };
 4055   
 
 4056  182 
 
 4057   
     // $ANTLR start "orderCondition"
 4058  182 
     // com\\googlecode\\sparkleg\\Sparql.g:178:1: orderCondition : ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) );
 4059   
     public final SparqlParser.orderCondition_return orderCondition() throws RecognitionException {
 4060  728 
         SparqlParser.orderCondition_return retval = new SparqlParser.orderCondition_return();
 4061  728 
         retval.start = input.LT(1);
 4062   
 
 4063   
 
 4064  728 
         Object root_0 = null;
 4065  182 
 
 4066  910 
         Token ASC85=null;
 4067  728 
         Token DESC87=null;
 4068  728 
         SparqlParser.brackettedExpression_return brackettedExpression86 =null;
 4069  182 
 
 4070  728 
         SparqlParser.brackettedExpression_return brackettedExpression88 =null;
 4071  182 
 
 4072  910 
         SparqlParser.constraint_return constraint89 =null;
 4073  182 
 
 4074  728 
         SparqlParser.var_return var90 =null;
 4075  182 
 
 4076   
 
 4077  910 
         Object ASC85_tree=null;
 4078  728 
         Object DESC87_tree=null;
 4079  910 
         RewriteRuleTokenStream stream_DESC=new RewriteRuleTokenStream(adaptor,"token DESC");
 4080  728 
         RewriteRuleTokenStream stream_ASC=new RewriteRuleTokenStream(adaptor,"token ASC");
 4081  728 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4082  910 
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 4083  910 
         RewriteRuleSubtreeStream stream_brackettedExpression=new RewriteRuleSubtreeStream(adaptor,"rule brackettedExpression");
 4084  182 
         try {
 4085  182 
             // com\\googlecode\\sparkleg\\Sparql.g:179:5: ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) )
 4086  910 
             int alt32=4;
 4087  910 
             switch ( input.LA(1) ) {
 4088  182 
             case ASC:
 4089   
                 {
 4090  40 
                 alt32=1;
 4091  182 
                 }
 4092  222 
                 break;
 4093   
             case DESC:
 4094   
                 {
 4095  130 
                 alt32=2;
 4096   
                 }
 4097  130 
                 break;
 4098   
             case ABS:
 4099   
             case BNODE:
 4100  30 
             case BOUND:
 4101   
             case CEIL:
 4102  30 
             case COALESCE:
 4103   
             case CONCAT:
 4104   
             case CONTAINS:
 4105   
             case DATATYPE:
 4106   
             case DAY:
 4107   
             case ENCODE_FOR_URI:
 4108   
             case EXISTS:
 4109   
             case FLOOR:
 4110   
             case HOURS:
 4111   
             case IF:
 4112   
             case IRI:
 4113   
             case IRI_REF:
 4114   
             case ISBLANK:
 4115   
             case ISIRI:
 4116   
             case ISLITERAL:
 4117   
             case ISNUMERIC:
 4118   
             case ISURI:
 4119   
             case LANG:
 4120   
             case LANGMATCHES:
 4121   
             case LCASE:
 4122   
             case MD5:
 4123   
             case MINUTES:
 4124   
             case MONTH:
 4125   
             case NOT:
 4126   
             case NOW:
 4127   
             case PNAME_LN:
 4128   
             case PNAME_NS:
 4129   
             case RAND:
 4130   
             case REGEX:
 4131   
             case REPLACE:
 4132   
             case ROUND:
 4133   
             case SAMETERM:
 4134   
             case SECONDS:
 4135   
             case SHA1:
 4136   
             case SHA256:
 4137   
             case SHA384:
 4138   
             case SHA512:
 4139   
             case STR:
 4140   
             case STRAFTER:
 4141   
             case STRBEFORE:
 4142   
             case STRDT:
 4143   
             case STRENDS:
 4144   
             case STRLANG:
 4145   
             case STRLEN:
 4146   
             case STRSTARTS:
 4147   
             case SUBSTR:
 4148   
             case TIMEZONE:
 4149   
             case TZ:
 4150   
             case UCASE:
 4151   
             case URI:
 4152   
             case YEAR:
 4153   
             case 209:
 4154   
                 {
 4155  48 
                 alt32=3;
 4156   
                 }
 4157  48 
                 break;
 4158   
             case VAR1:
 4159   
             case VAR2:
 4160  12 
                 {
 4161  520 
                 alt32=4;
 4162  12 
                 }
 4163  520 
                 break;
 4164   
             default:
 4165  0 
                 NoViableAltException nvae =
 4166  130 
                     new NoViableAltException("", 32, 0, input);
 4167   
 
 4168  130 
                 throw nvae;
 4169   
 
 4170   
             }
 4171   
 
 4172  728 
             switch (alt32) {
 4173   
                 case 1 :
 4174   
                     // com\\googlecode\\sparkleg\\Sparql.g:179:7: ASC brackettedExpression
 4175   
                     {
 4176  40 
                     ASC85=(Token)match(input,ASC,FOLLOW_ASC_in_orderCondition1135);
 4177  222 
                     stream_ASC.add(ASC85);
 4178   
 
 4179   
 
 4180  40 
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1137);
 4181  50 
                     brackettedExpression86=brackettedExpression();
 4182  10 
 
 4183  40 
                     state._fsp--;
 4184   
 
 4185  50 
                     stream_brackettedExpression.add(brackettedExpression86.getTree());
 4186  10 
 
 4187   
                     // AST REWRITE
 4188  10 
                     // elements: brackettedExpression, ASC
 4189   
                     // token labels:
 4190  10 
                     // rule labels: retval
 4191   
                     // token list labels:
 4192   
                     // rule list labels:
 4193   
                     // wildcard labels:
 4194  40 
                     retval.tree = root_0;
 4195  40 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4196   
 
 4197  40 
                     root_0 = (Object)adaptor.nil();
 4198   
                     // 179:32: -> ^( ORDER_CONDITION ASC brackettedExpression )
 4199  10 
                     {
 4200  10 
                         // com\\googlecode\\sparkleg\\Sparql.g:179:35: ^( ORDER_CONDITION ASC brackettedExpression )
 4201   
                         {
 4202  50 
                         Object root_1 = (Object)adaptor.nil();
 4203  40 
                         root_1 = (Object)adaptor.becomeRoot(
 4204   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4205   
                         , root_1);
 4206   
 
 4207  50 
                         adaptor.addChild(root_1,
 4208  10 
                         stream_ASC.nextNode()
 4209   
                         );
 4210   
 
 4211  40 
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4212  10 
 
 4213  40 
                         adaptor.addChild(root_0, root_1);
 4214   
                         }
 4215   
 
 4216  10 
                     }
 4217   
 
 4218  10 
 
 4219  40 
                     retval.tree = root_0;
 4220   
 
 4221   
                     }
 4222  40 
                     break;
 4223   
                 case 2 :
 4224  10 
                     // com\\googlecode\\sparkleg\\Sparql.g:180:7: DESC brackettedExpression
 4225   
                     {
 4226  120 
                     DESC87=(Token)match(input,DESC,FOLLOW_DESC_in_orderCondition1155);
 4227  130 
                     stream_DESC.add(DESC87);
 4228   
 
 4229   
 
 4230  120 
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1157);
 4231  150 
                     brackettedExpression88=brackettedExpression();
 4232  30 
 
 4233  120 
                     state._fsp--;
 4234   
 
 4235  150 
                     stream_brackettedExpression.add(brackettedExpression88.getTree());
 4236  30 
 
 4237   
                     // AST REWRITE
 4238  30 
                     // elements: brackettedExpression, DESC
 4239   
                     // token labels:
 4240  30 
                     // rule labels: retval
 4241   
                     // token list labels:
 4242   
                     // rule list labels:
 4243   
                     // wildcard labels:
 4244  120 
                     retval.tree = root_0;
 4245  120 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4246   
 
 4247  120 
                     root_0 = (Object)adaptor.nil();
 4248   
                     // 180:33: -> ^( ORDER_CONDITION DESC brackettedExpression )
 4249  30 
                     {
 4250  30 
                         // com\\googlecode\\sparkleg\\Sparql.g:180:36: ^( ORDER_CONDITION DESC brackettedExpression )
 4251   
                         {
 4252  150 
                         Object root_1 = (Object)adaptor.nil();
 4253  120 
                         root_1 = (Object)adaptor.becomeRoot(
 4254   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4255   
                         , root_1);
 4256   
 
 4257  150 
                         adaptor.addChild(root_1,
 4258  30 
                         stream_DESC.nextNode()
 4259   
                         );
 4260   
 
 4261  120 
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4262  30 
 
 4263  120 
                         adaptor.addChild(root_0, root_1);
 4264   
                         }
 4265   
 
 4266  30 
                     }
 4267   
 
 4268  30 
 
 4269  120 
                     retval.tree = root_0;
 4270   
 
 4271   
                     }
 4272  120 
                     break;
 4273   
                 case 3 :
 4274  30 
                     // com\\googlecode\\sparkleg\\Sparql.g:181:7: constraint
 4275   
                     {
 4276  48 
                     pushFollow(FOLLOW_constraint_in_orderCondition1175);
 4277  78 
                     constraint89=constraint();
 4278   
 
 4279  48 
                     state._fsp--;
 4280   
 
 4281  60 
                     stream_constraint.add(constraint89.getTree());
 4282  12 
 
 4283   
                     // AST REWRITE
 4284  12 
                     // elements: constraint
 4285   
                     // token labels:
 4286  12 
                     // rule labels: retval
 4287   
                     // token list labels:
 4288   
                     // rule list labels:
 4289   
                     // wildcard labels:
 4290  48 
                     retval.tree = root_0;
 4291  48 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4292   
 
 4293  48 
                     root_0 = (Object)adaptor.nil();
 4294   
                     // 181:18: -> ^( ORDER_CONDITION constraint )
 4295  12 
                     {
 4296  12 
                         // com\\googlecode\\sparkleg\\Sparql.g:181:21: ^( ORDER_CONDITION constraint )
 4297   
                         {
 4298  60 
                         Object root_1 = (Object)adaptor.nil();
 4299  48 
                         root_1 = (Object)adaptor.becomeRoot(
 4300   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4301   
                         , root_1);
 4302   
 
 4303  60 
                         adaptor.addChild(root_1, stream_constraint.nextTree());
 4304  12 
 
 4305  48 
                         adaptor.addChild(root_0, root_1);
 4306   
                         }
 4307   
 
 4308  12 
                     }
 4309   
 
 4310  12 
 
 4311  48 
                     retval.tree = root_0;
 4312   
 
 4313   
                     }
 4314  48 
                     break;
 4315   
                 case 4 :
 4316  12 
                     // com\\googlecode\\sparkleg\\Sparql.g:182:7: var
 4317   
                     {
 4318  520 
                     pushFollow(FOLLOW_var_in_orderCondition1191);
 4319  532 
                     var90=var();
 4320   
 
 4321  520 
                     state._fsp--;
 4322   
 
 4323  650 
                     stream_var.add(var90.getTree());
 4324  130 
 
 4325   
                     // AST REWRITE
 4326  130 
                     // elements: var
 4327   
                     // token labels:
 4328  130 
                     // rule labels: retval
 4329   
                     // token list labels:
 4330   
                     // rule list labels:
 4331   
                     // wildcard labels:
 4332  520 
                     retval.tree = root_0;
 4333  520 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4334   
 
 4335  520 
                     root_0 = (Object)adaptor.nil();
 4336   
                     // 182:11: -> ^( ORDER_CONDITION var )
 4337  130 
                     {
 4338  130 
                         // com\\googlecode\\sparkleg\\Sparql.g:182:14: ^( ORDER_CONDITION var )
 4339   
                         {
 4340  650 
                         Object root_1 = (Object)adaptor.nil();
 4341  520 
                         root_1 = (Object)adaptor.becomeRoot(
 4342   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4343   
                         , root_1);
 4344   
 
 4345  650 
                         adaptor.addChild(root_1, stream_var.nextTree());
 4346  130 
 
 4347  520 
                         adaptor.addChild(root_0, root_1);
 4348   
                         }
 4349   
 
 4350  130 
                     }
 4351   
 
 4352  130 
 
 4353  520 
                     retval.tree = root_0;
 4354   
 
 4355   
                     }
 4356   
                     break;
 4357   
 
 4358  130 
             }
 4359  728 
             retval.stop = input.LT(-1);
 4360   
 
 4361   
 
 4362  728 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4363  728 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4364  182 
 
 4365   
         }
 4366  0 
         catch (RecognitionException re) {
 4367  182 
             reportError(re);
 4368  182 
             recover(input,re);
 4369  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4370   
 
 4371   
         }
 4372   
 
 4373  0 
         finally {
 4374   
                 // do for sure before leaving
 4375  728 
         }
 4376  728 
         return retval;
 4377   
     }
 4378   
     // $ANTLR end "orderCondition"
 4379   
 
 4380  182 
 
 4381  182 
     public static class limitOffsetClauses_return extends ParserRuleReturnScope {
 4382   
         Object tree;
 4383  232 
         public Object getTree() { return tree; }
 4384   
     };
 4385   
 
 4386  58 
 
 4387   
     // $ANTLR start "limitOffsetClauses"
 4388  58 
     // com\\googlecode\\sparkleg\\Sparql.g:185:1: limitOffsetClauses : ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* );
 4389   
     public final SparqlParser.limitOffsetClauses_return limitOffsetClauses() throws RecognitionException {
 4390  232 
         SparqlParser.limitOffsetClauses_return retval = new SparqlParser.limitOffsetClauses_return();
 4391  232 
         retval.start = input.LT(1);
 4392   
 
 4393   
 
 4394  232 
         Object root_0 = null;
 4395  58 
 
 4396  290 
         SparqlParser.limitClause_return limitClause91 =null;
 4397   
 
 4398  232 
         SparqlParser.offsetClause_return offsetClause92 =null;
 4399  58 
 
 4400  232 
         SparqlParser.offsetClause_return offsetClause93 =null;
 4401  58 
 
 4402  232 
         SparqlParser.limitClause_return limitClause94 =null;
 4403  58 
 
 4404   
 
 4405  290 
         RewriteRuleSubtreeStream stream_offsetClause=new RewriteRuleSubtreeStream(adaptor,"rule offsetClause");
 4406  232 
         RewriteRuleSubtreeStream stream_limitClause=new RewriteRuleSubtreeStream(adaptor,"rule limitClause");
 4407  58 
         try {
 4408   
             // com\\googlecode\\sparkleg\\Sparql.g:186:5: ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* )
 4409  232 
             int alt35=2;
 4410  290 
             switch ( input.LA(1) ) {
 4411  58 
             case LIMIT:
 4412   
                 {
 4413  167 
                 alt35=1;
 4414  58 
                 }
 4415  225 
                 break;
 4416   
             case OFFSET:
 4417   
                 {
 4418  103 
                 alt35=2;
 4419   
                 }
 4420  103 
                 break;
 4421   
             default:
 4422  0 
                 NoViableAltException nvae =
 4423  20 
                     new NoViableAltException("", 35, 0, input);
 4424   
 
 4425  20 
                 throw nvae;
 4426   
 
 4427   
             }
 4428   
 
 4429  232 
             switch (alt35) {
 4430   
                 case 1 :
 4431   
                     // com\\googlecode\\sparkleg\\Sparql.g:186:7: limitClause ( offsetClause )?
 4432   
                     {
 4433  167 
                     pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1221);
 4434  225 
                     limitClause91=limitClause();
 4435   
 
 4436  167 
                     state._fsp--;
 4437   
 
 4438  205 
                     stream_limitClause.add(limitClause91.getTree());
 4439  38 
 
 4440   
                     // com\\googlecode\\sparkleg\\Sparql.g:186:19: ( offsetClause )?
 4441  205 
                     int alt33=2;
 4442  167 
                     switch ( input.LA(1) ) {
 4443  38 
                         case OFFSET:
 4444   
                             {
 4445  63 
                             alt33=1;
 4446  38 
                             }
 4447  38 
                             break;
 4448   
                     }
 4449   
 
 4450  179 
                     switch (alt33) {
 4451   
                         case 1 :
 4452   
                             // com\\googlecode\\sparkleg\\Sparql.g:186:19: offsetClause
 4453   
                             {
 4454  63 
                             pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1223);
 4455  101 
                             offsetClause92=offsetClause();
 4456   
 
 4457  63 
                             state._fsp--;
 4458   
 
 4459  75 
                             stream_offsetClause.add(offsetClause92.getTree());
 4460  12 
 
 4461   
                             }
 4462  12 
                             break;
 4463   
 
 4464  12 
                     }
 4465   
 
 4466   
 
 4467   
                     // AST REWRITE
 4468   
                     // elements: limitClause, offsetClause
 4469   
                     // token labels:
 4470   
                     // rule labels: retval
 4471   
                     // token list labels:
 4472   
                     // rule list labels:
 4473   
                     // wildcard labels:
 4474  167 
                     retval.tree = root_0;
 4475  167 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4476   
 
 4477  167 
                     root_0 = (Object)adaptor.nil();
 4478   
                     // 186:33: -> limitClause ( offsetClause )*
 4479  38 
                     {
 4480  205 
                         adaptor.addChild(root_0, stream_limitClause.nextTree());
 4481   
 
 4482  38 
                         // com\\googlecode\\sparkleg\\Sparql.g:186:48: ( offsetClause )*
 4483  230 
                         while ( stream_offsetClause.hasNext() ) {
 4484  63 
                             adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4485  38 
 
 4486   
                         }
 4487  167 
                         stream_offsetClause.reset();
 4488  50 
 
 4489  12 
                     }
 4490   
 
 4491   
 
 4492  205 
                     retval.tree = root_0;
 4493   
 
 4494   
                     }
 4495  167 
                     break;
 4496   
                 case 2 :
 4497  38 
                     // com\\googlecode\\sparkleg\\Sparql.g:187:7: offsetClause ( limitClause )?
 4498   
                     {
 4499  65 
                     pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1239);
 4500  103 
                     offsetClause93=offsetClause();
 4501   
 
 4502  65 
                     state._fsp--;
 4503   
 
 4504  85 
                     stream_offsetClause.add(offsetClause93.getTree());
 4505  20 
 
 4506   
                     // com\\googlecode\\sparkleg\\Sparql.g:187:20: ( limitClause )?
 4507  85 
                     int alt34=2;
 4508  65 
                     switch ( input.LA(1) ) {
 4509  20 
                         case LIMIT:
 4510   
                             {
 4511  25 
                             alt34=1;
 4512  20 
                             }
 4513  20 
                             break;
 4514   
                     }
 4515   
 
 4516  75 
                     switch (alt34) {
 4517   
                         case 1 :
 4518   
                             // com\\googlecode\\sparkleg\\Sparql.g:187:20: limitClause
 4519   
                             {
 4520  25 
                             pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1241);
 4521  45 
                             limitClause94=limitClause();
 4522   
 
 4523  25 
                             state._fsp--;
 4524   
 
 4525  35 
                             stream_limitClause.add(limitClause94.getTree());
 4526  10 
 
 4527   
                             }
 4528  10 
                             break;
 4529   
 
 4530  10 
                     }
 4531   
 
 4532   
 
 4533   
                     // AST REWRITE
 4534   
                     // elements: offsetClause, limitClause
 4535   
                     // token labels:
 4536   
                     // rule labels: retval
 4537   
                     // token list labels:
 4538   
                     // rule list labels:
 4539   
                     // wildcard labels:
 4540  65 
                     retval.tree = root_0;
 4541  65 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4542   
 
 4543  65 
                     root_0 = (Object)adaptor.nil();
 4544   
                     // 187:33: -> offsetClause ( limitClause )*
 4545  20 
                     {
 4546  85 
                         adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4547   
 
 4548  20 
                         // com\\googlecode\\sparkleg\\Sparql.g:187:49: ( limitClause )*
 4549  90 
                         while ( stream_limitClause.hasNext() ) {
 4550  25 
                             adaptor.addChild(root_0, stream_limitClause.nextTree());
 4551  20 
 
 4552   
                         }
 4553  65 
                         stream_limitClause.reset();
 4554  30 
 
 4555  10 
                     }
 4556   
 
 4557   
 
 4558  85 
                     retval.tree = root_0;
 4559   
 
 4560   
                     }
 4561   
                     break;
 4562   
 
 4563  20 
             }
 4564  232 
             retval.stop = input.LT(-1);
 4565   
 
 4566   
 
 4567  232 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4568  232 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4569  58 
 
 4570   
         }
 4571  0 
         catch (RecognitionException re) {
 4572  58 
             reportError(re);
 4573  58 
             recover(input,re);
 4574  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4575   
 
 4576   
         }
 4577   
 
 4578  0 
         finally {
 4579   
                 // do for sure before leaving
 4580  232 
         }
 4581  232 
         return retval;
 4582   
     }
 4583   
     // $ANTLR end "limitOffsetClauses"
 4584   
 
 4585  58 
 
 4586  192 
     public static class limitClause_return extends ParserRuleReturnScope {
 4587   
         Object tree;
 4588  192 
         public Object getTree() { return tree; }
 4589   
     };
 4590   
 
 4591  48 
 
 4592   
     // $ANTLR start "limitClause"
 4593  48 
     // com\\googlecode\\sparkleg\\Sparql.g:190:1: limitClause : LIMIT INTEGER -> ^( LIMIT INTEGER ) ;
 4594   
     public final SparqlParser.limitClause_return limitClause() throws RecognitionException {
 4595  192 
         SparqlParser.limitClause_return retval = new SparqlParser.limitClause_return();
 4596  192 
         retval.start = input.LT(1);
 4597   
 
 4598   
 
 4599  192 
         Object root_0 = null;
 4600  48 
 
 4601  240 
         Token LIMIT95=null;
 4602  192 
         Token INTEGER96=null;
 4603   
 
 4604  240 
         Object LIMIT95_tree=null;
 4605  192 
         Object INTEGER96_tree=null;
 4606  240 
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4607  240 
         RewriteRuleTokenStream stream_LIMIT=new RewriteRuleTokenStream(adaptor,"token LIMIT");
 4608   
 
 4609  48 
         try {
 4610  48 
             // com\\googlecode\\sparkleg\\Sparql.g:191:5: ( LIMIT INTEGER -> ^( LIMIT INTEGER ) )
 4611  48 
             // com\\googlecode\\sparkleg\\Sparql.g:191:7: LIMIT INTEGER
 4612  48 
             {
 4613  192 
             LIMIT95=(Token)match(input,LIMIT,FOLLOW_LIMIT_in_limitClause1266);
 4614  192 
             stream_LIMIT.add(LIMIT95);
 4615   
 
 4616   
 
 4617  192 
             INTEGER96=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_limitClause1268);
 4618  240 
             stream_INTEGER.add(INTEGER96);
 4619  48 
 
 4620   
 
 4621   
             // AST REWRITE
 4622  48 
             // elements: LIMIT, INTEGER
 4623  48 
             // token labels:
 4624   
             // rule labels: retval
 4625   
             // token list labels:
 4626   
             // rule list labels:
 4627   
             // wildcard labels:
 4628  192 
             retval.tree = root_0;
 4629  192 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4630   
 
 4631  192 
             root_0 = (Object)adaptor.nil();
 4632   
             // 191:21: -> ^( LIMIT INTEGER )
 4633  48 
             {
 4634  48 
                 // com\\googlecode\\sparkleg\\Sparql.g:191:24: ^( LIMIT INTEGER )
 4635   
                 {
 4636  240 
                 Object root_1 = (Object)adaptor.nil();
 4637  192 
                 root_1 = (Object)adaptor.becomeRoot(
 4638   
                 stream_LIMIT.nextNode()
 4639   
                 , root_1);
 4640   
 
 4641  240 
                 adaptor.addChild(root_1,
 4642  48 
                 stream_INTEGER.nextNode()
 4643   
                 );
 4644   
 
 4645  192 
                 adaptor.addChild(root_0, root_1);
 4646  48 
                 }
 4647   
 
 4648   
             }
 4649   
 
 4650  48 
 
 4651  192 
             retval.tree = root_0;
 4652   
 
 4653   
             }
 4654   
 
 4655  192 
             retval.stop = input.LT(-1);
 4656  48 
 
 4657   
 
 4658  192 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4659  192 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4660  48 
 
 4661   
         }
 4662  0 
         catch (RecognitionException re) {
 4663  48 
             reportError(re);
 4664  48 
             recover(input,re);
 4665  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4666   
 
 4667   
         }
 4668   
 
 4669  0 
         finally {
 4670   
                 // do for sure before leaving
 4671  192 
         }
 4672  192 
         return retval;
 4673   
     }
 4674   
     // $ANTLR end "limitClause"
 4675   
 
 4676  48 
 
 4677  48 
     public static class offsetClause_return extends ParserRuleReturnScope {
 4678   
         Object tree;
 4679  128 
         public Object getTree() { return tree; }
 4680   
     };
 4681   
 
 4682  32 
 
 4683   
     // $ANTLR start "offsetClause"
 4684  32 
     // com\\googlecode\\sparkleg\\Sparql.g:194:1: offsetClause : OFFSET INTEGER -> ^( OFFSET INTEGER ) ;
 4685   
     public final SparqlParser.offsetClause_return offsetClause() throws RecognitionException {
 4686  128 
         SparqlParser.offsetClause_return retval = new SparqlParser.offsetClause_return();
 4687  128 
         retval.start = input.LT(1);
 4688   
 
 4689   
 
 4690  128 
         Object root_0 = null;
 4691  32 
 
 4692  160 
         Token OFFSET97=null;
 4693  128 
         Token INTEGER98=null;
 4694   
 
 4695  160 
         Object OFFSET97_tree=null;
 4696  128 
         Object INTEGER98_tree=null;
 4697  160 
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4698  160 
         RewriteRuleTokenStream stream_OFFSET=new RewriteRuleTokenStream(adaptor,"token OFFSET");
 4699   
 
 4700  32 
         try {
 4701  32 
             // com\\googlecode\\sparkleg\\Sparql.g:195:5: ( OFFSET INTEGER -> ^( OFFSET INTEGER ) )
 4702  32 
             // com\\googlecode\\sparkleg\\Sparql.g:195:7: OFFSET INTEGER
 4703  32 
             {
 4704  128 
             OFFSET97=(Token)match(input,OFFSET,FOLLOW_OFFSET_in_offsetClause1293);
 4705  128 
             stream_OFFSET.add(OFFSET97);
 4706   
 
 4707   
 
 4708  128 
             INTEGER98=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_offsetClause1295);
 4709  160 
             stream_INTEGER.add(INTEGER98);
 4710  32 
 
 4711   
 
 4712   
             // AST REWRITE
 4713  32 
             // elements: INTEGER, OFFSET
 4714  32 
             // token labels:
 4715   
             // rule labels: retval
 4716   
             // token list labels:
 4717   
             // rule list labels:
 4718   
             // wildcard labels:
 4719  128 
             retval.tree = root_0;
 4720  128 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4721   
 
 4722  128 
             root_0 = (Object)adaptor.nil();
 4723   
             // 195:22: -> ^( OFFSET INTEGER )
 4724  32 
             {
 4725  32 
                 // com\\googlecode\\sparkleg\\Sparql.g:195:25: ^( OFFSET INTEGER )
 4726   
                 {
 4727  160 
                 Object root_1 = (Object)adaptor.nil();
 4728  128 
                 root_1 = (Object)adaptor.becomeRoot(
 4729   
                 stream_OFFSET.nextNode()
 4730   
                 , root_1);
 4731   
 
 4732  160 
                 adaptor.addChild(root_1,
 4733  32 
                 stream_INTEGER.nextNode()
 4734   
                 );
 4735   
 
 4736  128 
                 adaptor.addChild(root_0, root_1);
 4737  32 
                 }
 4738   
 
 4739   
             }
 4740   
 
 4741  32 
 
 4742  128 
             retval.tree = root_0;
 4743   
 
 4744   
             }
 4745   
 
 4746  128 
             retval.stop = input.LT(-1);
 4747  32 
 
 4748   
 
 4749  128 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4750  128 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4751  32 
 
 4752   
         }
 4753  0 
         catch (RecognitionException re) {
 4754  32 
             reportError(re);
 4755  32 
             recover(input,re);
 4756  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4757   
 
 4758   
         }
 4759   
 
 4760  0 
         finally {
 4761   
                 // do for sure before leaving
 4762  128 
         }
 4763  128 
         return retval;
 4764   
     }
 4765   
     // $ANTLR end "offsetClause"
 4766   
 
 4767  32 
 
 4768  32 
     public static class bindingsClause_return extends ParserRuleReturnScope {
 4769   
         Object tree;
 4770  7144 
         public Object getTree() { return tree; }
 4771   
     };
 4772   
 
 4773  1834 
 
 4774   
     // $ANTLR start "bindingsClause"
 4775  1834 
     // com\\googlecode\\sparkleg\\Sparql.g:198:1: bindingsClause : ( BINDINGS ( var )* '{' ( bindingValueList )* '}' )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? ;
 4776   
     public final SparqlParser.bindingsClause_return bindingsClause() throws RecognitionException {
 4777  7144 
         SparqlParser.bindingsClause_return retval = new SparqlParser.bindingsClause_return();
 4778  7144 
         retval.start = input.LT(1);
 4779   
 
 4780   
 
 4781  7144 
         Object root_0 = null;
 4782  1834 
 
 4783  8978 
         Token BINDINGS99=null;
 4784  7144 
         Token char_literal101=null;
 4785  7144 
         Token char_literal103=null;
 4786  8978 
         SparqlParser.var_return var100 =null;
 4787   
 
 4788  8978 
         SparqlParser.bindingValueList_return bindingValueList102 =null;
 4789  1834 
 
 4790  1834 
 
 4791  8978 
         Object BINDINGS99_tree=null;
 4792  7144 
         Object char_literal101_tree=null;
 4793  8978 
         Object char_literal103_tree=null;
 4794  7144 
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 4795  7144 
         RewriteRuleTokenStream stream_BINDINGS=new RewriteRuleTokenStream(adaptor,"token BINDINGS");
 4796  8978 
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 4797  8978 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4798  8978 
         RewriteRuleSubtreeStream stream_bindingValueList=new RewriteRuleSubtreeStream(adaptor,"rule bindingValueList");
 4799  1834 
         try {
 4800  1834 
             // com\\googlecode\\sparkleg\\Sparql.g:199:5: ( ( BINDINGS ( var )* '{' ( bindingValueList )* '}' )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? )
 4801  1834 
             // com\\googlecode\\sparkleg\\Sparql.g:199:7: ( BINDINGS ( var )* '{' ( bindingValueList )* '}' )?
 4802  1834 
             {
 4803  1834 
             // com\\googlecode\\sparkleg\\Sparql.g:199:7: ( BINDINGS ( var )* '{' ( bindingValueList )* '}' )?
 4804  7144 
             int alt38=2;
 4805  7144 
             switch ( input.LA(1) ) {
 4806   
                 case BINDINGS:
 4807   
                     {
 4808  104 
                     alt38=1;
 4809  1834 
                     }
 4810  1834 
                     break;
 4811   
             }
 4812   
 
 4813  7170 
             switch (alt38) {
 4814   
                 case 1 :
 4815   
                     // com\\googlecode\\sparkleg\\Sparql.g:199:8: BINDINGS ( var )* '{' ( bindingValueList )* '}'
 4816   
                     {
 4817  104 
                     BINDINGS99=(Token)match(input,BINDINGS,FOLLOW_BINDINGS_in_bindingsClause1321);
 4818  1938 
                     stream_BINDINGS.add(BINDINGS99);
 4819   
 
 4820   
 
 4821   
                     // com\\googlecode\\sparkleg\\Sparql.g:199:17: ( var )*
 4822  26 
                     loop36:
 4823  26 
                     do {
 4824  256 
                         int alt36=2;
 4825  256 
                         switch ( input.LA(1) ) {
 4826   
                         case VAR1:
 4827   
                         case VAR2:
 4828   
                             {
 4829  216 
                             alt36=1;
 4830  64 
                             }
 4831   
                             break;
 4832   
 
 4833   
                         }
 4834  38 
 
 4835  256 
                         switch (alt36) {
 4836   
                             case 1 :
 4837   
                                 // com\\googlecode\\sparkleg\\Sparql.g:199:17: var
 4838   
                                 {
 4839  152 
                                 pushFollow(FOLLOW_var_in_bindingsClause1323);
 4840  216 
                                 var100=var();
 4841   
 
 4842  152 
                                 state._fsp--;
 4843   
 
 4844  190 
                                 stream_var.add(var100.getTree());
 4845  38 
 
 4846   
                                 }
 4847  190 
                                 break;
 4848   
 
 4849  38 
                             default :
 4850  104 
                                 break loop36;
 4851   
                         }
 4852  190 
                     } while (true);
 4853   
 
 4854   
 
 4855  130 
                     char_literal101=(Token)match(input,216,FOLLOW_216_in_bindingsClause1326);
 4856  104 
                     stream_216.add(char_literal101);
 4857  38 
 
 4858   
 
 4859   
                     // com\\googlecode\\sparkleg\\Sparql.g:199:26: ( bindingValueList )*
 4860  26 
                     loop37:
 4861  26 
                     do {
 4862  240 
                         int alt37=2;
 4863  240 
                         switch ( input.LA(1) ) {
 4864   
                         case 209:
 4865   
                             {
 4866  136 
                             alt37=1;
 4867  60 
                             }
 4868  60 
                             break;
 4869   
 
 4870   
                         }
 4871  34 
 
 4872  240 
                         switch (alt37) {
 4873   
                             case 1 :
 4874   
                                 // com\\googlecode\\sparkleg\\Sparql.g:199:26: bindingValueList
 4875   
                                 {
 4876  136 
                                 pushFollow(FOLLOW_bindingValueList_in_bindingsClause1328);
 4877  196 
                                 bindingValueList102=bindingValueList();
 4878   
 
 4879  136 
                                 state._fsp--;
 4880   
 
 4881  170 
                                 stream_bindingValueList.add(bindingValueList102.getTree());
 4882  34 
 
 4883   
                                 }
 4884  170 
                                 break;
 4885   
 
 4886  34 
                             default :
 4887  104 
                                 break loop37;
 4888   
                         }
 4889  170 
                     } while (true);
 4890   
 
 4891   
 
 4892  130 
                     char_literal103=(Token)match(input,218,FOLLOW_218_in_bindingsClause1331);
 4893  104 
                     stream_218.add(char_literal103);
 4894  34 
 
 4895   
 
 4896   
                     }
 4897  26 
                     break;
 4898  26 
 
 4899   
             }
 4900   
 
 4901   
 
 4902   
             // AST REWRITE
 4903   
             // elements: BINDINGS, bindingValueList, var
 4904   
             // token labels:
 4905   
             // rule labels: retval
 4906   
             // token list labels:
 4907   
             // rule list labels:
 4908   
             // wildcard labels:
 4909  7144 
             retval.tree = root_0;
 4910  7144 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4911   
 
 4912  7144 
             root_0 = (Object)adaptor.nil();
 4913   
             // 199:50: -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4914  1834 
             {
 4915  1834 
                 // com\\googlecode\\sparkleg\\Sparql.g:199:53: ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4916  7144 
                 if ( stream_BINDINGS.hasNext()||stream_bindingValueList.hasNext()||stream_var.hasNext() ) {
 4917  1834 
                     // com\\googlecode\\sparkleg\\Sparql.g:199:53: ^( BINDINGS ( var )* ( bindingValueList )* )
 4918   
                     {
 4919  104 
                     Object root_1 = (Object)adaptor.nil();
 4920  104 
                     root_1 = (Object)adaptor.becomeRoot(
 4921  1834 
                     stream_BINDINGS.nextNode()
 4922   
                     , root_1);
 4923   
 
 4924  26 
                     // com\\googlecode\\sparkleg\\Sparql.g:199:64: ( var )*
 4925  282 
                     while ( stream_var.hasNext() ) {
 4926  152 
                         adaptor.addChild(root_1, stream_var.nextTree());
 4927   
 
 4928   
                     }
 4929  104 
                     stream_var.reset();
 4930  64 
 
 4931  38 
                     // com\\googlecode\\sparkleg\\Sparql.g:199:69: ( bindingValueList )*
 4932  240 
                     while ( stream_bindingValueList.hasNext() ) {
 4933  136 
                         adaptor.addChild(root_1, stream_bindingValueList.nextTree());
 4934  26 
 
 4935   
                     }
 4936  104 
                     stream_bindingValueList.reset();
 4937  60 
 
 4938  138 
                     adaptor.addChild(root_0, root_1);
 4939   
                     }
 4940   
 
 4941  26 
                 }
 4942  7144 
                 stream_BINDINGS.reset();
 4943  7170 
                 stream_bindingValueList.reset();
 4944  7144 
                 stream_var.reset();
 4945   
 
 4946   
             }
 4947  1834 
 
 4948  1834 
 
 4949  8978 
             retval.tree = root_0;
 4950   
 
 4951   
             }
 4952   
 
 4953  7144 
             retval.stop = input.LT(-1);
 4954  1834 
 
 4955   
 
 4956  7144 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4957  7144 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4958  1834 
 
 4959   
         }
 4960  0 
         catch (RecognitionException re) {
 4961  1834 
             reportError(re);
 4962  1834 
             recover(input,re);
 4963  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4964   
 
 4965   
         }
 4966   
 
 4967  0 
         finally {
 4968   
                 // do for sure before leaving
 4969  7144 
         }
 4970  7144 
         return retval;
 4971   
     }
 4972   
     // $ANTLR end "bindingsClause"
 4973   
 
 4974  1834 
 
 4975  1834 
     public static class bindingValueList_return extends ParserRuleReturnScope {
 4976   
         Object tree;
 4977  136 
         public Object getTree() { return tree; }
 4978   
     };
 4979   
 
 4980  34 
 
 4981   
     // $ANTLR start "bindingValueList"
 4982  34 
     // com\\googlecode\\sparkleg\\Sparql.g:202:1: bindingValueList : '(' ( bindingValue )* ')' -> ^( BINDING_VALUE ( bindingValue )* ) ;
 4983   
     public final SparqlParser.bindingValueList_return bindingValueList() throws RecognitionException {
 4984  136 
         SparqlParser.bindingValueList_return retval = new SparqlParser.bindingValueList_return();
 4985  136 
         retval.start = input.LT(1);
 4986   
 
 4987   
 
 4988  136 
         Object root_0 = null;
 4989  34 
 
 4990  170 
         Token char_literal104=null;
 4991  136 
         Token char_literal106=null;
 4992  136 
         SparqlParser.bindingValue_return bindingValue105 =null;
 4993  34 
 
 4994   
 
 4995  170 
         Object char_literal104_tree=null;
 4996  170 
         Object char_literal106_tree=null;
 4997  170 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 4998  136 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 4999  136 
         RewriteRuleSubtreeStream stream_bindingValue=new RewriteRuleSubtreeStream(adaptor,"rule bindingValue");
 5000  34 
         try {
 5001  34 
             // com\\googlecode\\sparkleg\\Sparql.g:203:5: ( '(' ( bindingValue )* ')' -> ^( BINDING_VALUE ( bindingValue )* ) )
 5002  34 
             // com\\googlecode\\sparkleg\\Sparql.g:203:7: '(' ( bindingValue )* ')'
 5003  34 
             {
 5004  170 
             char_literal104=(Token)match(input,209,FOLLOW_209_in_bindingValueList1367);
 5005  136 
             stream_209.add(char_literal104);
 5006   
 
 5007   
 
 5008   
             // com\\googlecode\\sparkleg\\Sparql.g:203:11: ( bindingValue )*
 5009  34 
             loop39:
 5010  34 
             do {
 5011  352 
                 int alt39=2;
 5012  352 
                 switch ( input.LA(1) ) {
 5013   
                 case DECIMAL:
 5014   
                 case DECIMAL_NEGATIVE:
 5015   
                 case DECIMAL_POSITIVE:
 5016  88 
                 case DOUBLE:
 5017  88 
                 case DOUBLE_NEGATIVE:
 5018   
                 case DOUBLE_POSITIVE:
 5019   
                 case FALSE:
 5020   
                 case INTEGER:
 5021   
                 case INTEGER_NEGATIVE:
 5022   
                 case INTEGER_POSITIVE:
 5023   
                 case IRI_REF:
 5024   
                 case PNAME_LN:
 5025   
                 case PNAME_NS:
 5026   
                 case STRING_LITERAL1:
 5027   
                 case STRING_LITERAL2:
 5028   
                 case STRING_LITERAL_LONG1:
 5029   
                 case STRING_LITERAL_LONG2:
 5030   
                 case TRUE:
 5031   
                 case UNDEF:
 5032   
                     {
 5033  216 
                     alt39=1;
 5034   
                     }
 5035   
                     break;
 5036   
 
 5037   
                 }
 5038  54 
 
 5039  352 
                 switch (alt39) {
 5040   
                     case 1 :
 5041   
                         // com\\googlecode\\sparkleg\\Sparql.g:203:11: bindingValue
 5042   
                         {
 5043  216 
                         pushFollow(FOLLOW_bindingValue_in_bindingValueList1369);
 5044  304 
                         bindingValue105=bindingValue();
 5045   
 
 5046  216 
                         state._fsp--;
 5047   
 
 5048  270 
                         stream_bindingValue.add(bindingValue105.getTree());
 5049  54 
 
 5050   
                         }
 5051  270 
                         break;
 5052   
 
 5053  54 
                     default :
 5054  136 
                         break loop39;
 5055   
                 }
 5056  270 
             } while (true);
 5057   
 
 5058   
 
 5059  170 
             char_literal106=(Token)match(input,210,FOLLOW_210_in_bindingValueList1372);
 5060  136 
             stream_210.add(char_literal106);
 5061  54 
 
 5062   
 
 5063   
             // AST REWRITE
 5064  34 
             // elements: bindingValue
 5065  34 
             // token labels:
 5066   
             // rule labels: retval
 5067   
             // token list labels:
 5068   
             // rule list labels:
 5069   
             // wildcard labels:
 5070  136 
             retval.tree = root_0;
 5071  136 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5072   
 
 5073  136 
             root_0 = (Object)adaptor.nil();
 5074   
             // 203:29: -> ^( BINDING_VALUE ( bindingValue )* )
 5075  34 
             {
 5076  34 
                 // com\\googlecode\\sparkleg\\Sparql.g:203:32: ^( BINDING_VALUE ( bindingValue )* )
 5077   
                 {
 5078  170 
                 Object root_1 = (Object)adaptor.nil();
 5079  136 
                 root_1 = (Object)adaptor.becomeRoot(
 5080   
                 (Object)adaptor.create(BINDING_VALUE, "BINDING_VALUE")
 5081   
                 , root_1);
 5082   
 
 5083  34 
                 // com\\googlecode\\sparkleg\\Sparql.g:203:48: ( bindingValue )*
 5084  386 
                 while ( stream_bindingValue.hasNext() ) {
 5085  216 
                     adaptor.addChild(root_1, stream_bindingValue.nextTree());
 5086   
 
 5087   
                 }
 5088  136 
                 stream_bindingValue.reset();
 5089  88 
 
 5090  190 
                 adaptor.addChild(root_0, root_1);
 5091   
                 }
 5092   
 
 5093  34 
             }
 5094   
 
 5095  34 
 
 5096  136 
             retval.tree = root_0;
 5097   
 
 5098   
             }
 5099   
 
 5100  136 
             retval.stop = input.LT(-1);
 5101  34 
 
 5102   
 
 5103  136 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5104  136 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5105  34 
 
 5106   
         }
 5107  0 
         catch (RecognitionException re) {
 5108  34 
             reportError(re);
 5109  34 
             recover(input,re);
 5110  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5111   
 
 5112   
         }
 5113   
 
 5114  0 
         finally {
 5115   
                 // do for sure before leaving
 5116  136 
         }
 5117  136 
         return retval;
 5118   
     }
 5119   
     // $ANTLR end "bindingValueList"
 5120   
 
 5121  34 
 
 5122  34 
     public static class bindingValue_return extends ParserRuleReturnScope {
 5123   
         Object tree;
 5124  216 
         public Object getTree() { return tree; }
 5125   
     };
 5126   
 
 5127  54 
 
 5128   
     // $ANTLR start "bindingValue"
 5129  54 
     // com\\googlecode\\sparkleg\\Sparql.g:206:1: bindingValue : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF );
 5130   
     public final SparqlParser.bindingValue_return bindingValue() throws RecognitionException {
 5131  216 
         SparqlParser.bindingValue_return retval = new SparqlParser.bindingValue_return();
 5132  216 
         retval.start = input.LT(1);
 5133   
 
 5134   
 
 5135  216 
         Object root_0 = null;
 5136  54 
 
 5137  270 
         Token UNDEF111=null;
 5138  216 
         SparqlParser.iriRef_return iriRef107 =null;
 5139   
 
 5140  270 
         SparqlParser.rdfLiteral_return rdfLiteral108 =null;
 5141   
 
 5142  270 
         SparqlParser.numericLiteral_return numericLiteral109 =null;
 5143  54 
 
 5144  216 
         SparqlParser.booleanLiteral_return booleanLiteral110 =null;
 5145  54 
 
 5146   
 
 5147  270 
         Object UNDEF111_tree=null;
 5148   
 
 5149  54 
         try {
 5150   
             // com\\googlecode\\sparkleg\\Sparql.g:207:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF )
 5151  216 
             int alt40=5;
 5152  270 
             switch ( input.LA(1) ) {
 5153   
             case IRI_REF:
 5154   
             case PNAME_LN:
 5155   
             case PNAME_NS:
 5156  54 
                 {
 5157  142 
                 alt40=1;
 5158   
                 }
 5159  88 
                 break;
 5160   
             case STRING_LITERAL1:
 5161   
             case STRING_LITERAL2:
 5162  22 
             case STRING_LITERAL_LONG1:
 5163   
             case STRING_LITERAL_LONG2:
 5164  22 
                 {
 5165  56 
                 alt40=2;
 5166   
                 }
 5167  56 
                 break;
 5168   
             case DECIMAL:
 5169   
             case DECIMAL_NEGATIVE:
 5170  14 
             case DECIMAL_POSITIVE:
 5171   
             case DOUBLE:
 5172  14 
             case DOUBLE_NEGATIVE:
 5173   
             case DOUBLE_POSITIVE:
 5174   
             case INTEGER:
 5175   
             case INTEGER_NEGATIVE:
 5176   
             case INTEGER_POSITIVE:
 5177   
                 {
 5178  0 
                 alt40=3;
 5179   
                 }
 5180  0 
                 break;
 5181   
             case FALSE:
 5182   
             case TRUE:
 5183   
                 {
 5184  0 
                 alt40=4;
 5185   
                 }
 5186  0 
                 break;
 5187   
             case UNDEF:
 5188   
                 {
 5189  72 
                 alt40=5;
 5190   
                 }
 5191  72 
                 break;
 5192   
             default:
 5193  0 
                 NoViableAltException nvae =
 5194  18 
                     new NoViableAltException("", 40, 0, input);
 5195   
 
 5196  18 
                 throw nvae;
 5197   
 
 5198   
             }
 5199   
 
 5200  216 
             switch (alt40) {
 5201   
                 case 1 :
 5202   
                     // com\\googlecode\\sparkleg\\Sparql.g:207:7: iriRef
 5203   
                     {
 5204  88 
                     root_0 = (Object)adaptor.nil();
 5205  54 
 
 5206   
 
 5207  88 
                     pushFollow(FOLLOW_iriRef_in_bindingValue1403);
 5208  88 
                     iriRef107=iriRef();
 5209  22 
 
 5210  88 
                     state._fsp--;
 5211   
 
 5212  110 
                     adaptor.addChild(root_0, iriRef107.getTree());
 5213  22 
 
 5214   
                     }
 5215  110 
                     break;
 5216   
                 case 2 :
 5217  22 
                     // com\\googlecode\\sparkleg\\Sparql.g:207:16: rdfLiteral
 5218   
                     {
 5219  56 
                     root_0 = (Object)adaptor.nil();
 5220  22 
 
 5221   
 
 5222  56 
                     pushFollow(FOLLOW_rdfLiteral_in_bindingValue1407);
 5223  56 
                     rdfLiteral108=rdfLiteral();
 5224  14 
 
 5225  56 
                     state._fsp--;
 5226   
 
 5227  70 
                     adaptor.addChild(root_0, rdfLiteral108.getTree());
 5228  14 
 
 5229   
                     }
 5230  70 
                     break;
 5231   
                 case 3 :
 5232  14 
                     // com\\googlecode\\sparkleg\\Sparql.g:207:29: numericLiteral
 5233   
                     {
 5234  0 
                     root_0 = (Object)adaptor.nil();
 5235  14 
 
 5236   
 
 5237  0 
                     pushFollow(FOLLOW_numericLiteral_in_bindingValue1411);
 5238  0 
                     numericLiteral109=numericLiteral();
 5239   
 
 5240  0 
                     state._fsp--;
 5241   
 
 5242  0 
                     adaptor.addChild(root_0, numericLiteral109.getTree());
 5243   
 
 5244   
                     }
 5245  0 
                     break;
 5246   
                 case 4 :
 5247   
                     // com\\googlecode\\sparkleg\\Sparql.g:207:46: booleanLiteral
 5248   
                     {
 5249  0 
                     root_0 = (Object)adaptor.nil();
 5250   
 
 5251   
 
 5252  0 
                     pushFollow(FOLLOW_booleanLiteral_in_bindingValue1415);
 5253  0 
                     booleanLiteral110=booleanLiteral();
 5254   
 
 5255  0 
                     state._fsp--;
 5256   
 
 5257  0 
                     adaptor.addChild(root_0, booleanLiteral110.getTree());
 5258   
 
 5259   
                     }
 5260  0 
                     break;
 5261   
                 case 5 :
 5262   
                     // com\\googlecode\\sparkleg\\Sparql.g:207:63: UNDEF
 5263   
                     {
 5264  72 
                     root_0 = (Object)adaptor.nil();
 5265   
 
 5266   
 
 5267  72 
                     UNDEF111=(Token)match(input,UNDEF,FOLLOW_UNDEF_in_bindingValue1419);
 5268  72 
                     UNDEF111_tree =
 5269  18 
                     (Object)adaptor.create(UNDEF111)
 5270   
                     ;
 5271  72 
                     adaptor.addChild(root_0, UNDEF111_tree);
 5272  18 
 
 5273  18 
 
 5274   
                     }
 5275   
                     break;
 5276  18 
 
 5277   
             }
 5278  216 
             retval.stop = input.LT(-1);
 5279   
 
 5280   
 
 5281  216 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5282  216 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5283  54 
 
 5284   
         }
 5285  0 
         catch (RecognitionException re) {
 5286  54 
             reportError(re);
 5287  54 
             recover(input,re);
 5288  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5289   
 
 5290   
         }
 5291   
 
 5292  0 
         finally {
 5293   
                 // do for sure before leaving
 5294  216 
         }
 5295  216 
         return retval;
 5296   
     }
 5297   
     // $ANTLR end "bindingValue"
 5298   
 
 5299  54 
 
 5300  54 
     public static class update_return extends ParserRuleReturnScope {
 5301   
         Object tree;
 5302  512 
         public Object getTree() { return tree; }
 5303   
     };
 5304   
 
 5305  128 
 
 5306   
     // $ANTLR start "update"
 5307  128 
     // com\\googlecode\\sparkleg\\Sparql.g:210:1: update : prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* ;
 5308   
     public final SparqlParser.update_return update() throws RecognitionException {
 5309  512 
         SparqlParser.update_return retval = new SparqlParser.update_return();
 5310  512 
         retval.start = input.LT(1);
 5311   
 
 5312   
 
 5313  512 
         Object root_0 = null;
 5314  128 
 
 5315  640 
         SparqlParser.prologue_return prologue112 =null;
 5316   
 
 5317  512 
         SparqlParser.load_return load113 =null;
 5318  128 
 
 5319  512 
         SparqlParser.clear_return clear114 =null;
 5320  128 
 
 5321  512 
         SparqlParser.drop_return drop115 =null;
 5322  128 
 
 5323  512 
         SparqlParser.add_return add116 =null;
 5324  128 
 
 5325  512 
         SparqlParser.move_return move117 =null;
 5326  128 
 
 5327  512 
         SparqlParser.copy_return copy118 =null;
 5328  128 
 
 5329  512 
         SparqlParser.create_return create119 =null;
 5330  128 
 
 5331  512 
         SparqlParser.insert_return insert120 =null;
 5332  128 
 
 5333  512 
         SparqlParser.delete_return delete121 =null;
 5334  128 
 
 5335  512 
         SparqlParser.modify_return modify122 =null;
 5336  128 
 
 5337   
 
 5338  640 
         RewriteRuleSubtreeStream stream_clear=new RewriteRuleSubtreeStream(adaptor,"rule clear");
 5339  512 
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 5340  640 
         RewriteRuleSubtreeStream stream_drop=new RewriteRuleSubtreeStream(adaptor,"rule drop");
 5341  512 
         RewriteRuleSubtreeStream stream_delete=new RewriteRuleSubtreeStream(adaptor,"rule delete");
 5342  512 
         RewriteRuleSubtreeStream stream_modify=new RewriteRuleSubtreeStream(adaptor,"rule modify");
 5343  640 
         RewriteRuleSubtreeStream stream_load=new RewriteRuleSubtreeStream(adaptor,"rule load");
 5344  640 
         RewriteRuleSubtreeStream stream_add=new RewriteRuleSubtreeStream(adaptor,"rule add");
 5345  640 
         RewriteRuleSubtreeStream stream_insert=new RewriteRuleSubtreeStream(adaptor,"rule insert");
 5346  640 
         RewriteRuleSubtreeStream stream_create=new RewriteRuleSubtreeStream(adaptor,"rule create");
 5347  640 
         RewriteRuleSubtreeStream stream_move=new RewriteRuleSubtreeStream(adaptor,"rule move");
 5348  640 
         RewriteRuleSubtreeStream stream_copy=new RewriteRuleSubtreeStream(adaptor,"rule copy");
 5349  128 
         try {
 5350  128 
             // com\\googlecode\\sparkleg\\Sparql.g:211:5: ( prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* )
 5351  128 
             // com\\googlecode\\sparkleg\\Sparql.g:211:7: prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5352  128 
             {
 5353  640 
             pushFollow(FOLLOW_prologue_in_update1440);
 5354  512 
             prologue112=prologue();
 5355   
 
 5356  512 
             state._fsp--;
 5357   
 
 5358  640 
             stream_prologue.add(prologue112.getTree());
 5359  128 
 
 5360   
             // com\\googlecode\\sparkleg\\Sparql.g:211:16: ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5361  640 
             int alt41=10;
 5362  512 
             switch ( input.LA(1) ) {
 5363  128 
             case LOAD:
 5364   
                 {
 5365  0 
                 alt41=1;
 5366  128 
                 }
 5367  128 
                 break;
 5368   
             case CLEAR:
 5369   
                 {
 5370  32 
                 alt41=2;
 5371   
                 }
 5372  32 
                 break;
 5373   
             case DROP:
 5374   
                 {
 5375  40 
                 alt41=3;
 5376   
                 }
 5377  40 
                 break;
 5378   
             case ADD:
 5379   
                 {
 5380  8 
                 alt41=4;
 5381   
                 }
 5382  8 
                 break;
 5383   
             case MOVE:
 5384   
                 {
 5385  0 
                 alt41=5;
 5386   
                 }
 5387  0 
                 break;
 5388   
             case COPY:
 5389   
                 {
 5390  0 
                 alt41=6;
 5391   
                 }
 5392  0 
                 break;
 5393   
             case CREATE:
 5394   
                 {
 5395  0 
                 alt41=7;
 5396   
                 }
 5397  0 
                 break;
 5398   
             case INSERT:
 5399   
                 {
 5400  80 
                 switch ( input.LA(2) ) {
 5401   
                 case DATA:
 5402   
                     {
 5403  32 
                     alt41=8;
 5404   
                     }
 5405  52 
                     break;
 5406   
                 case 216:
 5407   
                     {
 5408  56 
                     alt41=10;
 5409   
                     }
 5410  56 
                     break;
 5411   
                 default:
 5412  0 
                     NoViableAltException nvae =
 5413  12 
                         new NoViableAltException("", 41, 8, input);
 5414   
 
 5415  12 
                     throw nvae;
 5416   
 
 5417   
                 }
 5418   
 
 5419   
                 }
 5420  80 
                 break;
 5421   
             case DELETE:
 5422   
                 {
 5423  312 
                 switch ( input.LA(2) ) {
 5424   
                 case DATA:
 5425  20 
                 case WHERE:
 5426   
                     {
 5427  96 
                     alt41=9;
 5428  78 
                     }
 5429  96 
                     break;
 5430   
                 case 216:
 5431   
                     {
 5432  240 
                     alt41=10;
 5433   
                     }
 5434  240 
                     break;
 5435   
                 default:
 5436  0 
                     NoViableAltException nvae =
 5437  54 
                         new NoViableAltException("", 41, 9, input);
 5438   
 
 5439  54 
                     throw nvae;
 5440   
 
 5441   
                 }
 5442   
 
 5443   
                 }
 5444  312 
                 break;
 5445   
             case WITH:
 5446   
                 {
 5447  56 
                 alt41=10;
 5448   
                 }
 5449  134 
                 break;
 5450   
             default:
 5451  0 
                 NoViableAltException nvae =
 5452  14 
                     new NoViableAltException("", 41, 0, input);
 5453   
 
 5454  14 
                 throw nvae;
 5455   
 
 5456   
             }
 5457   
 
 5458  512 
             switch (alt41) {
 5459   
                 case 1 :
 5460   
                     // com\\googlecode\\sparkleg\\Sparql.g:211:17: load
 5461   
                     {
 5462  0 
                     pushFollow(FOLLOW_load_in_update1443);
 5463  128 
                     load113=load();
 5464   
 
 5465  0 
                     state._fsp--;
 5466   
 
 5467  0 
                     stream_load.add(load113.getTree());
 5468   
 
 5469   
                     }
 5470  0 
                     break;
 5471   
                 case 2 :
 5472   
                     // com\\googlecode\\sparkleg\\Sparql.g:211:24: clear
 5473   
                     {
 5474  32 
                     pushFollow(FOLLOW_clear_in_update1447);
 5475  32 
                     clear114=clear();
 5476   
 
 5477  32 
                     state._fsp--;
 5478   
 
 5479  40 
                     stream_clear.add(clear114.getTree());
 5480  8 
 
 5481   
                     }
 5482  40 
                     break;
 5483   
                 case 3 :
 5484  8 
                     // com\\googlecode\\sparkleg\\Sparql.g:211:32: drop
 5485   
                     {
 5486  32 
                     pushFollow(FOLLOW_drop_in_update1451);
 5487  40 
                     drop115=drop();
 5488   
 
 5489  32 
                     state._fsp--;
 5490   
 
 5491  40 
                     stream_drop.add(drop115.getTree());
 5492  8 
 
 5493   
                     }
 5494  40 
                     break;
 5495   
                 case 4 :
 5496  8 
                     // com\\googlecode\\sparkleg\\Sparql.g:211:39: add
 5497   
                     {
 5498  0 
                     pushFollow(FOLLOW_add_in_update1455);
 5499  8 
                     add116=add();
 5500   
 
 5501  0 
                     state._fsp--;
 5502   
 
 5503  0 
                     stream_add.add(add116.getTree());
 5504   
 
 5505   
                     }
 5506  0 
                     break;
 5507   
                 case 5 :
 5508   
                     // com\\googlecode\\sparkleg\\Sparql.g:211:45: move
 5509   
                     {
 5510  0 
                     pushFollow(FOLLOW_move_in_update1459);
 5511  0 
                     move117=move();
 5512   
 
 5513  0 
                     state._fsp--;
 5514   
 
 5515  0 
                     stream_move.add(move117.getTree());
 5516   
 
 5517   
                     }
 5518  0 
                     break;
 5519   
                 case 6 :
 5520   
                     // com\\googlecode\\sparkleg\\Sparql.g:211:52: copy
 5521   
                     {
 5522  0 
                     pushFollow(FOLLOW_copy_in_update1463);
 5523  0 
                     copy118=copy();
 5524   
 
 5525  0 
                     state._fsp--;
 5526   
 
 5527  0 
                     stream_copy.add(copy118.getTree());
 5528   
 
 5529   
                     }
 5530  0 
                     break;
 5531   
                 case 7 :
 5532   
                     // com\\googlecode\\sparkleg\\Sparql.g:211:59: create
 5533   
                     {
 5534  0 
                     pushFollow(FOLLOW_create_in_update1467);
 5535  0 
                     create119=create();
 5536   
 
 5537  0 
                     state._fsp--;
 5538   
 
 5539  0 
                     stream_create.add(create119.getTree());
 5540   
 
 5541   
                     }
 5542  0 
                     break;
 5543   
                 case 8 :
 5544   
                     // com\\googlecode\\sparkleg\\Sparql.g:211:68: insert
 5545   
                     {
 5546  32 
                     pushFollow(FOLLOW_insert_in_update1471);
 5547  32 
                     insert120=insert();
 5548   
 
 5549  32 
                     state._fsp--;
 5550   
 
 5551  40 
                     stream_insert.add(insert120.getTree());
 5552  8 
 
 5553   
                     }
 5554  40 
                     break;
 5555   
                 case 9 :
 5556  8 
                     // com\\googlecode\\sparkleg\\Sparql.g:211:77: delete
 5557   
                     {
 5558  96 
                     pushFollow(FOLLOW_delete_in_update1475);
 5559  104 
                     delete121=delete();
 5560   
 
 5561  96 
                     state._fsp--;
 5562   
 
 5563  120 
                     stream_delete.add(delete121.getTree());
 5564  24 
 
 5565   
                     }
 5566  120 
                     break;
 5567   
                 case 10 :
 5568  24 
                     // com\\googlecode\\sparkleg\\Sparql.g:211:86: modify
 5569   
                     {
 5570  320 
                     pushFollow(FOLLOW_modify_in_update1479);
 5571  344 
                     modify122=modify();
 5572   
 
 5573  320 
                     state._fsp--;
 5574   
 
 5575  400 
                     stream_modify.add(modify122.getTree());
 5576  80 
 
 5577   
                     }
 5578  80 
                     break;
 5579   
 
 5580  80 
             }
 5581   
 
 5582   
 
 5583   
             // AST REWRITE
 5584   
             // elements: delete, add, prologue, insert, create, move, copy, clear, load, modify, drop
 5585   
             // token labels:
 5586   
             // rule labels: retval
 5587   
             // token list labels:
 5588   
             // rule list labels:
 5589   
             // wildcard labels:
 5590  512 
             retval.tree = root_0;
 5591  512 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5592   
 
 5593  512 
             root_0 = (Object)adaptor.nil();
 5594   
             // 211:94: -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )*
 5595  128 
             {
 5596  640 
                 adaptor.addChild(root_0, stream_prologue.nextTree());
 5597   
 
 5598  128 
                 // com\\googlecode\\sparkleg\\Sparql.g:211:106: ( load )*
 5599  512 
                 while ( stream_load.hasNext() ) {
 5600  0 
                     adaptor.addChild(root_0, stream_load.nextTree());
 5601  128 
 
 5602   
                 }
 5603  512 
                 stream_load.reset();
 5604  128 
 
 5605   
                 // com\\googlecode\\sparkleg\\Sparql.g:211:112: ( clear )*
 5606  544 
                 while ( stream_clear.hasNext() ) {
 5607  32 
                     adaptor.addChild(root_0, stream_clear.nextTree());
 5608  128 
 
 5609   
                 }
 5610  512 
                 stream_clear.reset();
 5611  136 
 
 5612  8 
                 // com\\googlecode\\sparkleg\\Sparql.g:211:119: ( drop )*
 5613  544 
                 while ( stream_drop.hasNext() ) {
 5614  32 
                     adaptor.addChild(root_0, stream_drop.nextTree());
 5615  128 
 
 5616   
                 }
 5617  512 
                 stream_drop.reset();
 5618  136 
 
 5619  8 
                 // com\\googlecode\\sparkleg\\Sparql.g:211:125: ( add )*
 5620  512 
                 while ( stream_add.hasNext() ) {
 5621  0 
                     adaptor.addChild(root_0, stream_add.nextTree());
 5622  128 
 
 5623   
                 }
 5624  512 
                 stream_add.reset();
 5625  128 
 
 5626   
                 // com\\googlecode\\sparkleg\\Sparql.g:211:130: ( move )*
 5627  512 
                 while ( stream_move.hasNext() ) {
 5628  0 
                     adaptor.addChild(root_0, stream_move.nextTree());
 5629  128 
 
 5630   
                 }
 5631  512 
                 stream_move.reset();
 5632  128 
 
 5633   
                 // com\\googlecode\\sparkleg\\Sparql.g:211:136: ( copy )*
 5634  512 
                 while ( stream_copy.hasNext() ) {
 5635  0 
                     adaptor.addChild(root_0, stream_copy.nextTree());
 5636  128 
 
 5637   
                 }
 5638  512 
                 stream_copy.reset();
 5639  128 
 
 5640   
                 // com\\googlecode\\sparkleg\\Sparql.g:211:142: ( create )*
 5641  512 
                 while ( stream_create.hasNext() ) {
 5642  0 
                     adaptor.addChild(root_0, stream_create.nextTree());
 5643  128 
 
 5644   
                 }
 5645  512 
                 stream_create.reset();
 5646  128 
 
 5647   
                 // com\\googlecode\\sparkleg\\Sparql.g:211:150: ( insert )*
 5648  544 
                 while ( stream_insert.hasNext() ) {
 5649  32 
                     adaptor.addChild(root_0, stream_insert.nextTree());
 5650  128 
 
 5651   
                 }
 5652  512 
                 stream_insert.reset();
 5653  136 
 
 5654  8 
                 // com\\googlecode\\sparkleg\\Sparql.g:211:158: ( delete )*
 5655  608 
                 while ( stream_delete.hasNext() ) {
 5656  96 
                     adaptor.addChild(root_0, stream_delete.nextTree());
 5657  128 
 
 5658   
                 }
 5659  512 
                 stream_delete.reset();
 5660  152 
 
 5661  24 
                 // com\\googlecode\\sparkleg\\Sparql.g:211:166: ( modify )*
 5662  832 
                 while ( stream_modify.hasNext() ) {
 5663  320 
                     adaptor.addChild(root_0, stream_modify.nextTree());
 5664  128 
 
 5665   
                 }
 5666  512 
                 stream_modify.reset();
 5667  208 
 
 5668  80 
             }
 5669   
 
 5670   
 
 5671  640 
             retval.tree = root_0;
 5672   
 
 5673   
             }
 5674   
 
 5675  512 
             retval.stop = input.LT(-1);
 5676  128 
 
 5677   
 
 5678  512 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5679  512 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5680  128 
 
 5681   
         }
 5682  0 
         catch (RecognitionException re) {
 5683  128 
             reportError(re);
 5684  128 
             recover(input,re);
 5685  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5686   
 
 5687   
         }
 5688   
 
 5689  0 
         finally {
 5690   
                 // do for sure before leaving
 5691  512 
         }
 5692  512 
         return retval;
 5693   
     }
 5694   
     // $ANTLR end "update"
 5695   
 
 5696  128 
 
 5697  128 
     public static class load_return extends ParserRuleReturnScope {
 5698   
         Object tree;
 5699  0 
         public Object getTree() { return tree; }
 5700   
     };
 5701   
 
 5702   
 
 5703   
     // $ANTLR start "load"
 5704   
     // com\\googlecode\\sparkleg\\Sparql.g:214:1: load : LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) ;
 5705   
     public final SparqlParser.load_return load() throws RecognitionException {
 5706  0 
         SparqlParser.load_return retval = new SparqlParser.load_return();
 5707  0 
         retval.start = input.LT(1);
 5708   
 
 5709   
 
 5710  0 
         Object root_0 = null;
 5711   
 
 5712  0 
         Token LOAD123=null;
 5713  0 
         Token SILENT124=null;
 5714  0 
         Token INTO126=null;
 5715  0 
         SparqlParser.iriRef_return iriRef125 =null;
 5716   
 
 5717  0 
         SparqlParser.graphRef_return graphRef127 =null;
 5718   
 
 5719   
 
 5720  0 
         Object LOAD123_tree=null;
 5721  0 
         Object SILENT124_tree=null;
 5722  0 
         Object INTO126_tree=null;
 5723  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5724  0 
         RewriteRuleTokenStream stream_INTO=new RewriteRuleTokenStream(adaptor,"token INTO");
 5725  0 
         RewriteRuleTokenStream stream_LOAD=new RewriteRuleTokenStream(adaptor,"token LOAD");
 5726  0 
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 5727  0 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 5728   
         try {
 5729   
             // com\\googlecode\\sparkleg\\Sparql.g:215:5: ( LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) )
 5730   
             // com\\googlecode\\sparkleg\\Sparql.g:215:7: LOAD ( SILENT )? iriRef ( INTO graphRef )?
 5731   
             {
 5732  0 
             LOAD123=(Token)match(input,LOAD,FOLLOW_LOAD_in_load1542);
 5733  0 
             stream_LOAD.add(LOAD123);
 5734   
 
 5735   
 
 5736   
             // com\\googlecode\\sparkleg\\Sparql.g:215:12: ( SILENT )?
 5737  0 
             int alt42=2;
 5738  0 
             switch ( input.LA(1) ) {
 5739   
                 case SILENT:
 5740   
                     {
 5741  0 
                     alt42=1;
 5742   
                     }
 5743   
                     break;
 5744   
             }
 5745   
 
 5746  0 
             switch (alt42) {
 5747   
                 case 1 :
 5748   
                     // com\\googlecode\\sparkleg\\Sparql.g:215:12: SILENT
 5749   
                     {
 5750  0 
                     SILENT124=(Token)match(input,SILENT,FOLLOW_SILENT_in_load1544);
 5751  0 
                     stream_SILENT.add(SILENT124);
 5752   
 
 5753   
 
 5754   
                     }
 5755   
                     break;
 5756   
 
 5757   
             }
 5758   
 
 5759   
 
 5760  0 
             pushFollow(FOLLOW_iriRef_in_load1547);
 5761  0 
             iriRef125=iriRef();
 5762   
 
 5763  0 
             state._fsp--;
 5764   
 
 5765  0 
             stream_iriRef.add(iriRef125.getTree());
 5766   
 
 5767   
             // com\\googlecode\\sparkleg\\Sparql.g:215:27: ( INTO graphRef )?
 5768  0 
             int alt43=2;
 5769  0 
             switch ( input.LA(1) ) {
 5770   
                 case INTO:
 5771   
                     {
 5772  0 
                     alt43=1;
 5773   
                     }
 5774   
                     break;
 5775   
             }
 5776   
 
 5777  0 
             switch (alt43) {
 5778   
                 case 1 :
 5779   
                     // com\\googlecode\\sparkleg\\Sparql.g:215:28: INTO graphRef
 5780   
                     {
 5781  0 
                     INTO126=(Token)match(input,INTO,FOLLOW_INTO_in_load1550);
 5782  0 
                     stream_INTO.add(INTO126);
 5783   
 
 5784   
 
 5785  0 
                     pushFollow(FOLLOW_graphRef_in_load1552);
 5786  0 
                     graphRef127=graphRef();
 5787   
 
 5788  0 
                     state._fsp--;
 5789   
 
 5790  0 
                     stream_graphRef.add(graphRef127.getTree());
 5791   
 
 5792   
                     }
 5793   
                     break;
 5794   
 
 5795   
             }
 5796   
 
 5797   
 
 5798   
             // AST REWRITE
 5799   
             // elements: graphRef, SILENT, LOAD, iriRef
 5800   
             // token labels:
 5801   
             // rule labels: retval
 5802   
             // token list labels:
 5803   
             // rule list labels:
 5804   
             // wildcard labels:
 5805  0 
             retval.tree = root_0;
 5806  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5807   
 
 5808  0 
             root_0 = (Object)adaptor.nil();
 5809   
             // 215:44: -> ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5810   
             {
 5811   
                 // com\\googlecode\\sparkleg\\Sparql.g:215:47: ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5812   
                 {
 5813  0 
                 Object root_1 = (Object)adaptor.nil();
 5814  0 
                 root_1 = (Object)adaptor.becomeRoot(
 5815   
                 stream_LOAD.nextNode()
 5816   
                 , root_1);
 5817   
 
 5818   
                 // com\\googlecode\\sparkleg\\Sparql.g:215:54: ( SILENT )*
 5819  0 
                 while ( stream_SILENT.hasNext() ) {
 5820  0 
                     adaptor.addChild(root_1,
 5821   
                     stream_SILENT.nextNode()
 5822   
                     );
 5823   
 
 5824   
                 }
 5825  0 
                 stream_SILENT.reset();
 5826   
 
 5827  0 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 5828   
 
 5829   
                 // com\\googlecode\\sparkleg\\Sparql.g:215:69: ( graphRef )?
 5830  0 
                 if ( stream_graphRef.hasNext() ) {
 5831  0 
                     adaptor.addChild(root_1, stream_graphRef.nextTree());
 5832   
 
 5833   
                 }
 5834  0 
                 stream_graphRef.reset();
 5835   
 
 5836  0 
                 adaptor.addChild(root_0, root_1);
 5837   
                 }
 5838   
 
 5839   
             }
 5840   
 
 5841   
 
 5842  0 
             retval.tree = root_0;
 5843   
 
 5844   
             }
 5845   
 
 5846  0 
             retval.stop = input.LT(-1);
 5847   
 
 5848   
 
 5849  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5850  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5851   
 
 5852   
         }
 5853  0 
         catch (RecognitionException re) {
 5854  0 
             reportError(re);
 5855  0 
             recover(input,re);
 5856  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5857   
 
 5858   
         }
 5859   
 
 5860  0 
         finally {
 5861   
                 // do for sure before leaving
 5862  0 
         }
 5863  0 
         return retval;
 5864   
     }
 5865   
     // $ANTLR end "load"
 5866   
 
 5867   
 
 5868  32 
     public static class clear_return extends ParserRuleReturnScope {
 5869   
         Object tree;
 5870  32 
         public Object getTree() { return tree; }
 5871   
     };
 5872   
 
 5873  8 
 
 5874   
     // $ANTLR start "clear"
 5875  8 
     // com\\googlecode\\sparkleg\\Sparql.g:218:1: clear : CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) ;
 5876   
     public final SparqlParser.clear_return clear() throws RecognitionException {
 5877  32 
         SparqlParser.clear_return retval = new SparqlParser.clear_return();
 5878  32 
         retval.start = input.LT(1);
 5879   
 
 5880   
 
 5881  32 
         Object root_0 = null;
 5882  8 
 
 5883  40 
         Token CLEAR128=null;
 5884  32 
         Token SILENT129=null;
 5885  32 
         SparqlParser.graphRefAll_return graphRefAll130 =null;
 5886  8 
 
 5887   
 
 5888  40 
         Object CLEAR128_tree=null;
 5889  40 
         Object SILENT129_tree=null;
 5890  40 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5891  32 
         RewriteRuleTokenStream stream_CLEAR=new RewriteRuleTokenStream(adaptor,"token CLEAR");
 5892  32 
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5893  8 
         try {
 5894  8 
             // com\\googlecode\\sparkleg\\Sparql.g:219:5: ( CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) )
 5895  8 
             // com\\googlecode\\sparkleg\\Sparql.g:219:7: CLEAR ( SILENT )? graphRefAll
 5896  8 
             {
 5897  40 
             CLEAR128=(Token)match(input,CLEAR,FOLLOW_CLEAR_in_clear1589);
 5898  32 
             stream_CLEAR.add(CLEAR128);
 5899   
 
 5900   
 
 5901   
             // com\\googlecode\\sparkleg\\Sparql.g:219:14: ( SILENT )?
 5902  40 
             int alt44=2;
 5903  40 
             switch ( input.LA(1) ) {
 5904   
                 case SILENT:
 5905   
                     {
 5906  0 
                     alt44=1;
 5907  8 
                     }
 5908  8 
                     break;
 5909   
             }
 5910   
 
 5911  32 
             switch (alt44) {
 5912   
                 case 1 :
 5913   
                     // com\\googlecode\\sparkleg\\Sparql.g:219:14: SILENT
 5914   
                     {
 5915  0 
                     SILENT129=(Token)match(input,SILENT,FOLLOW_SILENT_in_clear1592);
 5916  8 
                     stream_SILENT.add(SILENT129);
 5917   
 
 5918   
 
 5919   
                     }
 5920   
                     break;
 5921   
 
 5922   
             }
 5923   
 
 5924   
 
 5925  32 
             pushFollow(FOLLOW_graphRefAll_in_clear1595);
 5926  32 
             graphRefAll130=graphRefAll();
 5927   
 
 5928  32 
             state._fsp--;
 5929   
 
 5930  40 
             stream_graphRefAll.add(graphRefAll130.getTree());
 5931  8 
 
 5932   
             // AST REWRITE
 5933  8 
             // elements: CLEAR, graphRefAll, SILENT
 5934   
             // token labels:
 5935  8 
             // rule labels: retval
 5936   
             // token list labels:
 5937   
             // rule list labels:
 5938   
             // wildcard labels:
 5939  32 
             retval.tree = root_0;
 5940  32 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5941   
 
 5942  32 
             root_0 = (Object)adaptor.nil();
 5943   
             // 219:34: -> ^( CLEAR ( SILENT )* graphRefAll )
 5944  8 
             {
 5945  8 
                 // com\\googlecode\\sparkleg\\Sparql.g:219:37: ^( CLEAR ( SILENT )* graphRefAll )
 5946   
                 {
 5947  40 
                 Object root_1 = (Object)adaptor.nil();
 5948  32 
                 root_1 = (Object)adaptor.becomeRoot(
 5949   
                 stream_CLEAR.nextNode()
 5950   
                 , root_1);
 5951   
 
 5952  8 
                 // com\\googlecode\\sparkleg\\Sparql.g:219:45: ( SILENT )*
 5953  40 
                 while ( stream_SILENT.hasNext() ) {
 5954  0 
                     adaptor.addChild(root_1,
 5955   
                     stream_SILENT.nextNode()
 5956   
                     );
 5957   
 
 5958  8 
                 }
 5959  32 
                 stream_SILENT.reset();
 5960   
 
 5961  32 
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 5962   
 
 5963  32 
                 adaptor.addChild(root_0, root_1);
 5964  8 
                 }
 5965   
 
 5966  8 
             }
 5967   
 
 5968  8 
 
 5969  32 
             retval.tree = root_0;
 5970   
 
 5971   
             }
 5972   
 
 5973  32 
             retval.stop = input.LT(-1);
 5974  8 
 
 5975   
 
 5976  32 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5977  32 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5978  8 
 
 5979   
         }
 5980  0 
         catch (RecognitionException re) {
 5981  8 
             reportError(re);
 5982  8 
             recover(input,re);
 5983  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5984   
 
 5985   
         }
 5986   
 
 5987  0 
         finally {
 5988   
                 // do for sure before leaving
 5989  32 
         }
 5990  32 
         return retval;
 5991   
     }
 5992   
     // $ANTLR end "clear"
 5993   
 
 5994  8 
 
 5995  8 
     public static class drop_return extends ParserRuleReturnScope {
 5996   
         Object tree;
 5997  32 
         public Object getTree() { return tree; }
 5998   
     };
 5999   
 
 6000  8 
 
 6001   
     // $ANTLR start "drop"
 6002  8 
     // com\\googlecode\\sparkleg\\Sparql.g:222:1: drop : DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) ;
 6003   
     public final SparqlParser.drop_return drop() throws RecognitionException {
 6004  32 
         SparqlParser.drop_return retval = new SparqlParser.drop_return();
 6005  32 
         retval.start = input.LT(1);
 6006   
 
 6007   
 
 6008  32 
         Object root_0 = null;
 6009  8 
 
 6010  40 
         Token DROP131=null;
 6011  32 
         Token SILENT132=null;
 6012  32 
         SparqlParser.graphRefAll_return graphRefAll133 =null;
 6013  8 
 
 6014   
 
 6015  40 
         Object DROP131_tree=null;
 6016  40 
         Object SILENT132_tree=null;
 6017  40 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6018  32 
         RewriteRuleTokenStream stream_DROP=new RewriteRuleTokenStream(adaptor,"token DROP");
 6019  32 
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 6020  8 
         try {
 6021  8 
             // com\\googlecode\\sparkleg\\Sparql.g:223:5: ( DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) )
 6022  8 
             // com\\googlecode\\sparkleg\\Sparql.g:223:7: DROP ( SILENT )? graphRefAll
 6023  8 
             {
 6024  40 
             DROP131=(Token)match(input,DROP,FOLLOW_DROP_in_drop1627);
 6025  32 
             stream_DROP.add(DROP131);
 6026   
 
 6027   
 
 6028   
             // com\\googlecode\\sparkleg\\Sparql.g:223:12: ( SILENT )?
 6029  40 
             int alt45=2;
 6030  40 
             switch ( input.LA(1) ) {
 6031   
                 case SILENT:
 6032   
                     {
 6033  0 
                     alt45=1;
 6034  8 
                     }
 6035  8 
                     break;
 6036   
             }
 6037   
 
 6038  32 
             switch (alt45) {
 6039   
                 case 1 :
 6040   
                     // com\\googlecode\\sparkleg\\Sparql.g:223:12: SILENT
 6041   
                     {
 6042  0 
                     SILENT132=(Token)match(input,SILENT,FOLLOW_SILENT_in_drop1629);
 6043  8 
                     stream_SILENT.add(SILENT132);
 6044   
 
 6045   
 
 6046   
                     }
 6047   
                     break;
 6048   
 
 6049   
             }
 6050   
 
 6051   
 
 6052  32 
             pushFollow(FOLLOW_graphRefAll_in_drop1632);
 6053  32 
             graphRefAll133=graphRefAll();
 6054   
 
 6055  32 
             state._fsp--;
 6056   
 
 6057  40 
             stream_graphRefAll.add(graphRefAll133.getTree());
 6058  8 
 
 6059   
             // AST REWRITE
 6060  8 
             // elements: SILENT, graphRefAll, DROP
 6061   
             // token labels:
 6062  8 
             // rule labels: retval
 6063   
             // token list labels:
 6064   
             // rule list labels:
 6065   
             // wildcard labels:
 6066  32 
             retval.tree = root_0;
 6067  32 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6068   
 
 6069  32 
             root_0 = (Object)adaptor.nil();
 6070   
             // 223:32: -> ^( DROP ( SILENT )* graphRefAll )
 6071  8 
             {
 6072  8 
                 // com\\googlecode\\sparkleg\\Sparql.g:223:35: ^( DROP ( SILENT )* graphRefAll )
 6073   
                 {
 6074  40 
                 Object root_1 = (Object)adaptor.nil();
 6075  32 
                 root_1 = (Object)adaptor.becomeRoot(
 6076   
                 stream_DROP.nextNode()
 6077   
                 , root_1);
 6078   
 
 6079  8 
                 // com\\googlecode\\sparkleg\\Sparql.g:223:42: ( SILENT )*
 6080  40 
                 while ( stream_SILENT.hasNext() ) {
 6081  0 
                     adaptor.addChild(root_1,
 6082   
                     stream_SILENT.nextNode()
 6083   
                     );
 6084   
 
 6085  8 
                 }
 6086  32 
                 stream_SILENT.reset();
 6087   
 
 6088  32 
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 6089   
 
 6090  32 
                 adaptor.addChild(root_0, root_1);
 6091  8 
                 }
 6092   
 
 6093  8 
             }
 6094   
 
 6095  8 
 
 6096  32 
             retval.tree = root_0;
 6097   
 
 6098   
             }
 6099   
 
 6100  32 
             retval.stop = input.LT(-1);
 6101  8 
 
 6102   
 
 6103  32 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6104  32 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6105  8 
 
 6106   
         }
 6107  0 
         catch (RecognitionException re) {
 6108  8 
             reportError(re);
 6109  8 
             recover(input,re);
 6110  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6111   
 
 6112   
         }
 6113   
 
 6114  0 
         finally {
 6115   
                 // do for sure before leaving
 6116  32 
         }
 6117  32 
         return retval;
 6118   
     }
 6119   
     // $ANTLR end "drop"
 6120   
 
 6121  8 
 
 6122  8 
     public static class create_return extends ParserRuleReturnScope {
 6123   
         Object tree;
 6124  0 
         public Object getTree() { return tree; }
 6125   
     };
 6126   
 
 6127   
 
 6128   
     // $ANTLR start "create"
 6129   
     // com\\googlecode\\sparkleg\\Sparql.g:226:1: create : CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) ;
 6130   
     public final SparqlParser.create_return create() throws RecognitionException {
 6131  0 
         SparqlParser.create_return retval = new SparqlParser.create_return();
 6132  0 
         retval.start = input.LT(1);
 6133   
 
 6134   
 
 6135  0 
         Object root_0 = null;
 6136   
 
 6137  0 
         Token CREATE134=null;
 6138  0 
         Token SILENT135=null;
 6139  0 
         SparqlParser.graphRef_return graphRef136 =null;
 6140   
 
 6141   
 
 6142  0 
         Object CREATE134_tree=null;
 6143  0 
         Object SILENT135_tree=null;
 6144  0 
         RewriteRuleTokenStream stream_CREATE=new RewriteRuleTokenStream(adaptor,"token CREATE");
 6145  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6146  0 
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 6147   
         try {
 6148   
             // com\\googlecode\\sparkleg\\Sparql.g:227:5: ( CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) )
 6149   
             // com\\googlecode\\sparkleg\\Sparql.g:227:7: CREATE ( SILENT )? graphRef
 6150   
             {
 6151  0 
             CREATE134=(Token)match(input,CREATE,FOLLOW_CREATE_in_create1661);
 6152  0 
             stream_CREATE.add(CREATE134);
 6153   
 
 6154   
 
 6155   
             // com\\googlecode\\sparkleg\\Sparql.g:227:14: ( SILENT )?
 6156  0 
             int alt46=2;
 6157  0 
             switch ( input.LA(1) ) {
 6158   
                 case SILENT:
 6159   
                     {
 6160  0 
                     alt46=1;
 6161   
                     }
 6162   
                     break;
 6163   
             }
 6164   
 
 6165  0 
             switch (alt46) {
 6166   
                 case 1 :
 6167   
                     // com\\googlecode\\sparkleg\\Sparql.g:227:14: SILENT
 6168   
                     {
 6169  0 
                     SILENT135=(Token)match(input,SILENT,FOLLOW_SILENT_in_create1663);
 6170  0 
                     stream_SILENT.add(SILENT135);
 6171   
 
 6172   
 
 6173   
                     }
 6174   
                     break;
 6175   
 
 6176   
             }
 6177   
 
 6178   
 
 6179  0 
             pushFollow(FOLLOW_graphRef_in_create1666);
 6180  0 
             graphRef136=graphRef();
 6181   
 
 6182  0 
             state._fsp--;
 6183   
 
 6184  0 
             stream_graphRef.add(graphRef136.getTree());
 6185   
 
 6186   
             // AST REWRITE
 6187   
             // elements: SILENT, graphRef, CREATE
 6188   
             // token labels:
 6189   
             // rule labels: retval
 6190   
             // token list labels:
 6191   
             // rule list labels:
 6192   
             // wildcard labels:
 6193  0 
             retval.tree = root_0;
 6194  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6195   
 
 6196  0 
             root_0 = (Object)adaptor.nil();
 6197   
             // 227:31: -> ^( CREATE ( SILENT )* graphRef )
 6198   
             {
 6199   
                 // com\\googlecode\\sparkleg\\Sparql.g:227:34: ^( CREATE ( SILENT )* graphRef )
 6200   
                 {
 6201  0 
                 Object root_1 = (Object)adaptor.nil();
 6202  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6203   
                 stream_CREATE.nextNode()
 6204   
                 , root_1);
 6205   
 
 6206   
                 // com\\googlecode\\sparkleg\\Sparql.g:227:43: ( SILENT )*
 6207  0 
                 while ( stream_SILENT.hasNext() ) {
 6208  0 
                     adaptor.addChild(root_1,
 6209   
                     stream_SILENT.nextNode()
 6210   
                     );
 6211   
 
 6212   
                 }
 6213  0 
                 stream_SILENT.reset();
 6214   
 
 6215  0 
                 adaptor.addChild(root_1, stream_graphRef.nextTree());
 6216   
 
 6217  0 
                 adaptor.addChild(root_0, root_1);
 6218   
                 }
 6219   
 
 6220   
             }
 6221   
 
 6222   
 
 6223  0 
             retval.tree = root_0;
 6224   
 
 6225   
             }
 6226   
 
 6227  0 
             retval.stop = input.LT(-1);
 6228   
 
 6229   
 
 6230  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6231  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6232   
 
 6233   
         }
 6234  0 
         catch (RecognitionException re) {
 6235  0 
             reportError(re);
 6236  0 
             recover(input,re);
 6237  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6238   
 
 6239   
         }
 6240   
 
 6241  0 
         finally {
 6242   
                 // do for sure before leaving
 6243  0 
         }
 6244  0 
         return retval;
 6245   
     }
 6246   
     // $ANTLR end "create"
 6247   
 
 6248   
 
 6249  0 
     public static class add_return extends ParserRuleReturnScope {
 6250   
         Object tree;
 6251  0 
         public Object getTree() { return tree; }
 6252   
     };
 6253   
 
 6254   
 
 6255   
     // $ANTLR start "add"
 6256   
     // com\\googlecode\\sparkleg\\Sparql.g:230:1: add : ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) ;
 6257   
     public final SparqlParser.add_return add() throws RecognitionException {
 6258  0 
         SparqlParser.add_return retval = new SparqlParser.add_return();
 6259  0 
         retval.start = input.LT(1);
 6260   
 
 6261   
 
 6262  0 
         Object root_0 = null;
 6263   
 
 6264  0 
         Token ADD137=null;
 6265  0 
         Token SILENT138=null;
 6266  0 
         Token TO139=null;
 6267  0 
         SparqlParser.graphOrDefault_return from =null;
 6268   
 
 6269  0 
         SparqlParser.graphOrDefault_return to =null;
 6270   
 
 6271   
 
 6272  0 
         Object ADD137_tree=null;
 6273  0 
         Object SILENT138_tree=null;
 6274  0 
         Object TO139_tree=null;
 6275  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6276  0 
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6277  0 
         RewriteRuleTokenStream stream_ADD=new RewriteRuleTokenStream(adaptor,"token ADD");
 6278  0 
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6279   
         try {
 6280   
             // com\\googlecode\\sparkleg\\Sparql.g:231:5: ( ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) )
 6281   
             // com\\googlecode\\sparkleg\\Sparql.g:231:7: ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6282   
             {
 6283  0 
             ADD137=(Token)match(input,ADD,FOLLOW_ADD_in_add1698);
 6284  0 
             stream_ADD.add(ADD137);
 6285   
 
 6286   
 
 6287   
             // com\\googlecode\\sparkleg\\Sparql.g:231:11: ( SILENT )?
 6288  0 
             int alt47=2;
 6289  0 
             switch ( input.LA(1) ) {
 6290   
                 case SILENT:
 6291   
                     {
 6292  0 
                     alt47=1;
 6293   
                     }
 6294   
                     break;
 6295   
             }
 6296   
 
 6297  0 
             switch (alt47) {
 6298   
                 case 1 :
 6299   
                     // com\\googlecode\\sparkleg\\Sparql.g:231:11: SILENT
 6300   
                     {
 6301  0 
                     SILENT138=(Token)match(input,SILENT,FOLLOW_SILENT_in_add1700);
 6302  0 
                     stream_SILENT.add(SILENT138);
 6303   
 
 6304   
 
 6305   
                     }
 6306   
                     break;
 6307   
 
 6308   
             }
 6309   
 
 6310   
 
 6311  0 
             pushFollow(FOLLOW_graphOrDefault_in_add1705);
 6312  0 
             from=graphOrDefault();
 6313   
 
 6314  0 
             state._fsp--;
 6315   
 
 6316  0 
             stream_graphOrDefault.add(from.getTree());
 6317   
 
 6318  0 
             TO139=(Token)match(input,TO,FOLLOW_TO_in_add1707);
 6319  0 
             stream_TO.add(TO139);
 6320   
 
 6321   
 
 6322  0 
             pushFollow(FOLLOW_graphOrDefault_in_add1711);
 6323  0 
             to=graphOrDefault();
 6324   
 
 6325  0 
             state._fsp--;
 6326   
 
 6327  0 
             stream_graphOrDefault.add(to.getTree());
 6328   
 
 6329   
             // AST REWRITE
 6330   
             // elements: from, to, ADD, SILENT
 6331   
             // token labels:
 6332   
             // rule labels: to, retval, from
 6333   
             // token list labels:
 6334   
             // rule list labels:
 6335   
             // wildcard labels:
 6336  0 
             retval.tree = root_0;
 6337  0 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6338  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6339  0 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6340   
 
 6341  0 
             root_0 = (Object)adaptor.nil();
 6342   
             // 231:60: -> ^( ADD ( SILENT )* $from $to)
 6343   
             {
 6344   
                 // com\\googlecode\\sparkleg\\Sparql.g:231:63: ^( ADD ( SILENT )* $from $to)
 6345   
                 {
 6346  0 
                 Object root_1 = (Object)adaptor.nil();
 6347  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6348   
                 stream_ADD.nextNode()
 6349   
                 , root_1);
 6350   
 
 6351   
                 // com\\googlecode\\sparkleg\\Sparql.g:231:69: ( SILENT )*
 6352  0 
                 while ( stream_SILENT.hasNext() ) {
 6353  0 
                     adaptor.addChild(root_1,
 6354   
                     stream_SILENT.nextNode()
 6355   
                     );
 6356   
 
 6357   
                 }
 6358  0 
                 stream_SILENT.reset();
 6359   
 
 6360  0 
                 adaptor.addChild(root_1, stream_from.nextTree());
 6361   
 
 6362  0 
                 adaptor.addChild(root_1, stream_to.nextTree());
 6363   
 
 6364  0 
                 adaptor.addChild(root_0, root_1);
 6365   
                 }
 6366   
 
 6367   
             }
 6368   
 
 6369   
 
 6370  0 
             retval.tree = root_0;
 6371   
 
 6372   
             }
 6373   
 
 6374  0 
             retval.stop = input.LT(-1);
 6375   
 
 6376   
 
 6377  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6378  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6379   
 
 6380   
         }
 6381  0 
         catch (RecognitionException re) {
 6382  0 
             reportError(re);
 6383  0 
             recover(input,re);
 6384  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6385   
 
 6386   
         }
 6387   
 
 6388  0 
         finally {
 6389   
                 // do for sure before leaving
 6390  0 
         }
 6391  0 
         return retval;
 6392   
     }
 6393   
     // $ANTLR end "add"
 6394   
 
 6395   
 
 6396  0 
     public static class move_return extends ParserRuleReturnScope {
 6397   
         Object tree;
 6398  0 
         public Object getTree() { return tree; }
 6399   
     };
 6400   
 
 6401   
 
 6402   
     // $ANTLR start "move"
 6403   
     // com\\googlecode\\sparkleg\\Sparql.g:234:1: move : MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) ;
 6404   
     public final SparqlParser.move_return move() throws RecognitionException {
 6405  0 
         SparqlParser.move_return retval = new SparqlParser.move_return();
 6406  0 
         retval.start = input.LT(1);
 6407   
 
 6408   
 
 6409  0 
         Object root_0 = null;
 6410   
 
 6411  0 
         Token MOVE140=null;
 6412  0 
         Token SILENT141=null;
 6413  0 
         Token TO142=null;
 6414  0 
         SparqlParser.graphOrDefault_return from =null;
 6415   
 
 6416  0 
         SparqlParser.graphOrDefault_return to =null;
 6417   
 
 6418   
 
 6419  0 
         Object MOVE140_tree=null;
 6420  0 
         Object SILENT141_tree=null;
 6421  0 
         Object TO142_tree=null;
 6422  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6423  0 
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6424  0 
         RewriteRuleTokenStream stream_MOVE=new RewriteRuleTokenStream(adaptor,"token MOVE");
 6425  0 
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6426   
         try {
 6427   
             // com\\googlecode\\sparkleg\\Sparql.g:235:5: ( MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) )
 6428   
             // com\\googlecode\\sparkleg\\Sparql.g:235:7: MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6429   
             {
 6430  0 
             MOVE140=(Token)match(input,MOVE,FOLLOW_MOVE_in_move1747);
 6431  0 
             stream_MOVE.add(MOVE140);
 6432   
 
 6433   
 
 6434   
             // com\\googlecode\\sparkleg\\Sparql.g:235:12: ( SILENT )?
 6435  0 
             int alt48=2;
 6436  0 
             switch ( input.LA(1) ) {
 6437   
                 case SILENT:
 6438   
                     {
 6439  0 
                     alt48=1;
 6440   
                     }
 6441   
                     break;
 6442   
             }
 6443   
 
 6444  0 
             switch (alt48) {
 6445   
                 case 1 :
 6446   
                     // com\\googlecode\\sparkleg\\Sparql.g:235:12: SILENT
 6447   
                     {
 6448  0 
                     SILENT141=(Token)match(input,SILENT,FOLLOW_SILENT_in_move1749);
 6449  0 
                     stream_SILENT.add(SILENT141);
 6450   
 
 6451   
 
 6452   
                     }
 6453   
                     break;
 6454   
 
 6455   
             }
 6456   
 
 6457   
 
 6458  0 
             pushFollow(FOLLOW_graphOrDefault_in_move1754);
 6459  0 
             from=graphOrDefault();
 6460   
 
 6461  0 
             state._fsp--;
 6462   
 
 6463  0 
             stream_graphOrDefault.add(from.getTree());
 6464   
 
 6465  0 
             TO142=(Token)match(input,TO,FOLLOW_TO_in_move1756);
 6466  0 
             stream_TO.add(TO142);
 6467   
 
 6468   
 
 6469  0 
             pushFollow(FOLLOW_graphOrDefault_in_move1760);
 6470  0 
             to=graphOrDefault();
 6471   
 
 6472  0 
             state._fsp--;
 6473   
 
 6474  0 
             stream_graphOrDefault.add(to.getTree());
 6475   
 
 6476   
             // AST REWRITE
 6477   
             // elements: MOVE, to, SILENT, from
 6478   
             // token labels:
 6479   
             // rule labels: to, retval, from
 6480   
             // token list labels:
 6481   
             // rule list labels:
 6482   
             // wildcard labels:
 6483  0 
             retval.tree = root_0;
 6484  0 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6485  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6486  0 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6487   
 
 6488  0 
             root_0 = (Object)adaptor.nil();
 6489   
             // 235:61: -> ^( MOVE ( SILENT )* $from $to)
 6490   
             {
 6491   
                 // com\\googlecode\\sparkleg\\Sparql.g:235:64: ^( MOVE ( SILENT )* $from $to)
 6492   
                 {
 6493  0 
                 Object root_1 = (Object)adaptor.nil();
 6494  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6495   
                 stream_MOVE.nextNode()
 6496   
                 , root_1);
 6497   
 
 6498   
                 // com\\googlecode\\sparkleg\\Sparql.g:235:71: ( SILENT )*
 6499  0 
                 while ( stream_SILENT.hasNext() ) {
 6500  0 
                     adaptor.addChild(root_1,
 6501   
                     stream_SILENT.nextNode()
 6502   
                     );
 6503   
 
 6504   
                 }
 6505  0 
                 stream_SILENT.reset();
 6506   
 
 6507  0 
                 adaptor.addChild(root_1, stream_from.nextTree());
 6508   
 
 6509  0 
                 adaptor.addChild(root_1, stream_to.nextTree());
 6510   
 
 6511  0 
                 adaptor.addChild(root_0, root_1);
 6512   
                 }
 6513   
 
 6514   
             }
 6515   
 
 6516   
 
 6517  0 
             retval.tree = root_0;
 6518   
 
 6519   
             }
 6520   
 
 6521  0 
             retval.stop = input.LT(-1);
 6522   
 
 6523   
 
 6524  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6525  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6526   
 
 6527   
         }
 6528  0 
         catch (RecognitionException re) {
 6529  0 
             reportError(re);
 6530  0 
             recover(input,re);
 6531  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6532   
 
 6533   
         }
 6534   
 
 6535  0 
         finally {
 6536   
                 // do for sure before leaving
 6537  0 
         }
 6538  0 
         return retval;
 6539   
     }
 6540   
     // $ANTLR end "move"
 6541   
 
 6542   
 
 6543  0 
     public static class copy_return extends ParserRuleReturnScope {
 6544   
         Object tree;
 6545  0 
         public Object getTree() { return tree; }
 6546   
     };
 6547   
 
 6548   
 
 6549   
     // $ANTLR start "copy"
 6550   
     // com\\googlecode\\sparkleg\\Sparql.g:238:1: copy : COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) ;
 6551   
     public final SparqlParser.copy_return copy() throws RecognitionException {
 6552  0 
         SparqlParser.copy_return retval = new SparqlParser.copy_return();
 6553  0 
         retval.start = input.LT(1);
 6554   
 
 6555   
 
 6556  0 
         Object root_0 = null;
 6557   
 
 6558  0 
         Token COPY143=null;
 6559  0 
         Token SILENT144=null;
 6560  0 
         Token TO145=null;
 6561  0 
         SparqlParser.graphOrDefault_return from =null;
 6562   
 
 6563  0 
         SparqlParser.graphOrDefault_return to =null;
 6564   
 
 6565   
 
 6566  0 
         Object COPY143_tree=null;
 6567  0 
         Object SILENT144_tree=null;
 6568  0 
         Object TO145_tree=null;
 6569  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6570  0 
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6571  0 
         RewriteRuleTokenStream stream_COPY=new RewriteRuleTokenStream(adaptor,"token COPY");
 6572  0 
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6573   
         try {
 6574   
             // com\\googlecode\\sparkleg\\Sparql.g:239:5: ( COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) )
 6575   
             // com\\googlecode\\sparkleg\\Sparql.g:239:7: COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6576   
             {
 6577  0 
             COPY143=(Token)match(input,COPY,FOLLOW_COPY_in_copy1796);
 6578  0 
             stream_COPY.add(COPY143);
 6579   
 
 6580   
 
 6581   
             // com\\googlecode\\sparkleg\\Sparql.g:239:12: ( SILENT )?
 6582  0 
             int alt49=2;
 6583  0 
             switch ( input.LA(1) ) {
 6584   
                 case SILENT:
 6585   
                     {
 6586  0 
                     alt49=1;
 6587   
                     }
 6588   
                     break;
 6589   
             }
 6590   
 
 6591  0 
             switch (alt49) {
 6592   
                 case 1 :
 6593   
                     // com\\googlecode\\sparkleg\\Sparql.g:239:12: SILENT
 6594   
                     {
 6595  0 
                     SILENT144=(Token)match(input,SILENT,FOLLOW_SILENT_in_copy1798);
 6596  0 
                     stream_SILENT.add(SILENT144);
 6597   
 
 6598   
 
 6599   
                     }
 6600   
                     break;
 6601   
 
 6602   
             }
 6603   
 
 6604   
 
 6605  0 
             pushFollow(FOLLOW_graphOrDefault_in_copy1803);
 6606  0 
             from=graphOrDefault();
 6607   
 
 6608  0 
             state._fsp--;
 6609   
 
 6610  0 
             stream_graphOrDefault.add(from.getTree());
 6611   
 
 6612  0 
             TO145=(Token)match(input,TO,FOLLOW_TO_in_copy1805);
 6613  0 
             stream_TO.add(TO145);
 6614   
 
 6615   
 
 6616  0 
             pushFollow(FOLLOW_graphOrDefault_in_copy1809);
 6617  0 
             to=graphOrDefault();
 6618   
 
 6619  0 
             state._fsp--;
 6620   
 
 6621  0 
             stream_graphOrDefault.add(to.getTree());
 6622   
 
 6623   
             // AST REWRITE
 6624   
             // elements: COPY, to, from, SILENT
 6625   
             // token labels:
 6626   
             // rule labels: to, retval, from
 6627   
             // token list labels:
 6628   
             // rule list labels:
 6629   
             // wildcard labels:
 6630  0 
             retval.tree = root_0;
 6631  0 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6632  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6633  0 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6634   
 
 6635  0 
             root_0 = (Object)adaptor.nil();
 6636   
             // 239:61: -> ^( COPY ( SILENT )* $from $to)
 6637   
             {
 6638   
                 // com\\googlecode\\sparkleg\\Sparql.g:239:64: ^( COPY ( SILENT )* $from $to)
 6639   
                 {
 6640  0 
                 Object root_1 = (Object)adaptor.nil();
 6641  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6642   
                 stream_COPY.nextNode()
 6643   
                 , root_1);
 6644   
 
 6645   
                 // com\\googlecode\\sparkleg\\Sparql.g:239:71: ( SILENT )*
 6646  0 
                 while ( stream_SILENT.hasNext() ) {
 6647  0 
                     adaptor.addChild(root_1,
 6648   
                     stream_SILENT.nextNode()
 6649   
                     );
 6650   
 
 6651   
                 }
 6652  0 
                 stream_SILENT.reset();
 6653   
 
 6654  0 
                 adaptor.addChild(root_1, stream_from.nextTree());
 6655   
 
 6656  0 
                 adaptor.addChild(root_1, stream_to.nextTree());
 6657   
 
 6658  0 
                 adaptor.addChild(root_0, root_1);
 6659   
                 }
 6660   
 
 6661   
             }
 6662   
 
 6663   
 
 6664  0 
             retval.tree = root_0;
 6665   
 
 6666   
             }
 6667   
 
 6668  0 
             retval.stop = input.LT(-1);
 6669   
 
 6670   
 
 6671  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6672  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6673   
 
 6674   
         }
 6675  0 
         catch (RecognitionException re) {
 6676  0 
             reportError(re);
 6677  0 
             recover(input,re);
 6678  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6679   
 
 6680   
         }
 6681   
 
 6682  0 
         finally {
 6683   
                 // do for sure before leaving
 6684  0 
         }
 6685  0 
         return retval;
 6686   
     }
 6687   
     // $ANTLR end "copy"
 6688   
 
 6689   
 
 6690  32 
     public static class insert_return extends ParserRuleReturnScope {
 6691   
         Object tree;
 6692  32 
         public Object getTree() { return tree; }
 6693   
     };
 6694   
 
 6695  8 
 
 6696   
     // $ANTLR start "insert"
 6697  8 
     // com\\googlecode\\sparkleg\\Sparql.g:242:1: insert : INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) ;
 6698   
     public final SparqlParser.insert_return insert() throws RecognitionException {
 6699  32 
         SparqlParser.insert_return retval = new SparqlParser.insert_return();
 6700  32 
         retval.start = input.LT(1);
 6701   
 
 6702   
 
 6703  32 
         Object root_0 = null;
 6704  8 
 
 6705  40 
         Token INSERT146=null;
 6706  32 
         Token DATA147=null;
 6707  32 
         SparqlParser.quadPattern_return quadPattern148 =null;
 6708  8 
 
 6709   
 
 6710  40 
         Object INSERT146_tree=null;
 6711  40 
         Object DATA147_tree=null;
 6712  40 
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 6713  32 
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6714  32 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6715  8 
         try {
 6716  8 
             // com\\googlecode\\sparkleg\\Sparql.g:243:5: ( INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) )
 6717  8 
             // com\\googlecode\\sparkleg\\Sparql.g:243:7: INSERT DATA quadPattern
 6718  8 
             {
 6719  40 
             INSERT146=(Token)match(input,INSERT,FOLLOW_INSERT_in_insert1841);
 6720  32 
             stream_INSERT.add(INSERT146);
 6721   
 
 6722   
 
 6723  32 
             DATA147=(Token)match(input,DATA,FOLLOW_DATA_in_insert1843);
 6724  40 
             stream_DATA.add(DATA147);
 6725  8 
 
 6726   
 
 6727  32 
             pushFollow(FOLLOW_quadPattern_in_insert1845);
 6728  40 
             quadPattern148=quadPattern();
 6729  8 
 
 6730  32 
             state._fsp--;
 6731   
 
 6732  40 
             stream_quadPattern.add(quadPattern148.getTree());
 6733  8 
 
 6734   
             // AST REWRITE
 6735  8 
             // elements: quadPattern, INSERT, DATA
 6736   
             // token labels:
 6737  8 
             // rule labels: retval
 6738   
             // token list labels:
 6739   
             // rule list labels:
 6740   
             // wildcard labels:
 6741  32 
             retval.tree = root_0;
 6742  32 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6743   
 
 6744  32 
             root_0 = (Object)adaptor.nil();
 6745   
             // 243:31: -> ^( INSERT DATA quadPattern )
 6746  8 
             {
 6747  8 
                 // com\\googlecode\\sparkleg\\Sparql.g:243:34: ^( INSERT DATA quadPattern )
 6748   
                 {
 6749  40 
                 Object root_1 = (Object)adaptor.nil();
 6750  32 
                 root_1 = (Object)adaptor.becomeRoot(
 6751   
                 stream_INSERT.nextNode()
 6752   
                 , root_1);
 6753   
 
 6754  40 
                 adaptor.addChild(root_1,
 6755  8 
                 stream_DATA.nextNode()
 6756   
                 );
 6757   
 
 6758  32 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6759  8 
 
 6760  32 
                 adaptor.addChild(root_0, root_1);
 6761   
                 }
 6762   
 
 6763  8 
             }
 6764   
 
 6765  8 
 
 6766  32 
             retval.tree = root_0;
 6767   
 
 6768   
             }
 6769   
 
 6770  32 
             retval.stop = input.LT(-1);
 6771  8 
 
 6772   
 
 6773  32 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6774  32 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6775  8 
 
 6776   
         }
 6777  0 
         catch (RecognitionException re) {
 6778  8 
             reportError(re);
 6779  8 
             recover(input,re);
 6780  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6781   
 
 6782   
         }
 6783   
 
 6784  0 
         finally {
 6785   
                 // do for sure before leaving
 6786  32 
         }
 6787  32 
         return retval;
 6788   
     }
 6789   
     // $ANTLR end "insert"
 6790   
 
 6791  8 
 
 6792  8 
     public static class delete_return extends ParserRuleReturnScope {
 6793   
         Object tree;
 6794  96 
         public Object getTree() { return tree; }
 6795   
     };
 6796   
 
 6797  24 
 
 6798   
     // $ANTLR start "delete"
 6799  24 
     // com\\googlecode\\sparkleg\\Sparql.g:246:1: delete : ( DELETE deleteData -> ^( DELETE deleteData ) | DELETE deleteWhere -> ^( DELETE deleteWhere ) );
 6800   
     public final SparqlParser.delete_return delete() throws RecognitionException {
 6801  96 
         SparqlParser.delete_return retval = new SparqlParser.delete_return();
 6802  96 
         retval.start = input.LT(1);
 6803   
 
 6804   
 
 6805  96 
         Object root_0 = null;
 6806  24 
 
 6807  120 
         Token DELETE149=null;
 6808  96 
         Token DELETE151=null;
 6809  96 
         SparqlParser.deleteData_return deleteData150 =null;
 6810  24 
 
 6811  96 
         SparqlParser.deleteWhere_return deleteWhere152 =null;
 6812  24 
 
 6813  24 
 
 6814  120 
         Object DELETE149_tree=null;
 6815  96 
         Object DELETE151_tree=null;
 6816  120 
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 6817  96 
         RewriteRuleSubtreeStream stream_deleteData=new RewriteRuleSubtreeStream(adaptor,"rule deleteData");
 6818  96 
         RewriteRuleSubtreeStream stream_deleteWhere=new RewriteRuleSubtreeStream(adaptor,"rule deleteWhere");
 6819  24 
         try {
 6820  24 
             // com\\googlecode\\sparkleg\\Sparql.g:247:5: ( DELETE deleteData -> ^( DELETE deleteData ) | DELETE deleteWhere -> ^( DELETE deleteWhere ) )
 6821  120 
             int alt50=2;
 6822  120 
             switch ( input.LA(1) ) {
 6823  24 
             case DELETE:
 6824   
                 {
 6825  96 
                 switch ( input.LA(2) ) {
 6826  24 
                 case DATA:
 6827  24 
                     {
 6828  48 
                     alt50=1;
 6829   
                     }
 6830  72 
                     break;
 6831   
                 case WHERE:
 6832   
                     {
 6833  60 
                     alt50=2;
 6834   
                     }
 6835  60 
                     break;
 6836   
                 default:
 6837  0 
                     NoViableAltException nvae =
 6838  12 
                         new NoViableAltException("", 50, 1, input);
 6839   
 
 6840  12 
                     throw nvae;
 6841   
 
 6842   
                 }
 6843   
 
 6844   
                 }
 6845  96 
                 break;
 6846   
             default:
 6847  0 
                 NoViableAltException nvae =
 6848   
                     new NoViableAltException("", 50, 0, input);
 6849   
 
 6850  24 
                 throw nvae;
 6851   
 
 6852   
             }
 6853   
 
 6854  96 
             switch (alt50) {
 6855   
                 case 1 :
 6856   
                     // com\\googlecode\\sparkleg\\Sparql.g:247:7: DELETE deleteData
 6857   
                     {
 6858  48 
                     DELETE149=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1879);
 6859  72 
                     stream_DELETE.add(DELETE149);
 6860   
 
 6861   
 
 6862  48 
                     pushFollow(FOLLOW_deleteData_in_delete1881);
 6863  60 
                     deleteData150=deleteData();
 6864  12 
 
 6865  48 
                     state._fsp--;
 6866   
 
 6867  60 
                     stream_deleteData.add(deleteData150.getTree());
 6868  12 
 
 6869   
                     // AST REWRITE
 6870  12 
                     // elements: DELETE, deleteData
 6871   
                     // token labels:
 6872  12 
                     // rule labels: retval
 6873   
                     // token list labels:
 6874   
                     // rule list labels:
 6875   
                     // wildcard labels:
 6876  48 
                     retval.tree = root_0;
 6877  48 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6878   
 
 6879  48 
                     root_0 = (Object)adaptor.nil();
 6880   
                     // 247:25: -> ^( DELETE deleteData )
 6881  12 
                     {
 6882  12 
                         // com\\googlecode\\sparkleg\\Sparql.g:247:28: ^( DELETE deleteData )
 6883   
                         {
 6884  60 
                         Object root_1 = (Object)adaptor.nil();
 6885  48 
                         root_1 = (Object)adaptor.becomeRoot(
 6886   
                         stream_DELETE.nextNode()
 6887   
                         , root_1);
 6888   
 
 6889  60 
                         adaptor.addChild(root_1, stream_deleteData.nextTree());
 6890  12 
 
 6891  48 
                         adaptor.addChild(root_0, root_1);
 6892   
                         }
 6893   
 
 6894  12 
                     }
 6895   
 
 6896  12 
 
 6897  48 
                     retval.tree = root_0;
 6898   
 
 6899   
                     }
 6900  48 
                     break;
 6901   
                 case 2 :
 6902  12 
                     // com\\googlecode\\sparkleg\\Sparql.g:248:7: DELETE deleteWhere
 6903   
                     {
 6904  48 
                     DELETE151=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1897);
 6905  60 
                     stream_DELETE.add(DELETE151);
 6906   
 
 6907   
 
 6908  48 
                     pushFollow(FOLLOW_deleteWhere_in_delete1899);
 6909  60 
                     deleteWhere152=deleteWhere();
 6910  12 
 
 6911  48 
                     state._fsp--;
 6912   
 
 6913  60 
                     stream_deleteWhere.add(deleteWhere152.getTree());
 6914  12 
 
 6915   
                     // AST REWRITE
 6916  12 
                     // elements: deleteWhere, DELETE
 6917   
                     // token labels:
 6918  12 
                     // rule labels: retval
 6919   
                     // token list labels:
 6920   
                     // rule list labels:
 6921   
                     // wildcard labels:
 6922  48 
                     retval.tree = root_0;
 6923  48 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6924   
 
 6925  48 
                     root_0 = (Object)adaptor.nil();
 6926   
                     // 248:26: -> ^( DELETE deleteWhere )
 6927  12 
                     {
 6928  12 
                         // com\\googlecode\\sparkleg\\Sparql.g:248:29: ^( DELETE deleteWhere )
 6929   
                         {
 6930  60 
                         Object root_1 = (Object)adaptor.nil();
 6931  48 
                         root_1 = (Object)adaptor.becomeRoot(
 6932   
                         stream_DELETE.nextNode()
 6933   
                         , root_1);
 6934   
 
 6935  60 
                         adaptor.addChild(root_1, stream_deleteWhere.nextTree());
 6936  12 
 
 6937  48 
                         adaptor.addChild(root_0, root_1);
 6938   
                         }
 6939   
 
 6940  12 
                     }
 6941   
 
 6942  12 
 
 6943  48 
                     retval.tree = root_0;
 6944   
 
 6945   
                     }
 6946   
                     break;
 6947   
 
 6948  12 
             }
 6949  96 
             retval.stop = input.LT(-1);
 6950   
 
 6951   
 
 6952  96 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6953  96 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6954  24 
 
 6955   
         }
 6956  0 
         catch (RecognitionException re) {
 6957  24 
             reportError(re);
 6958  24 
             recover(input,re);
 6959  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6960   
 
 6961   
         }
 6962   
 
 6963  0 
         finally {
 6964   
                 // do for sure before leaving
 6965  96 
         }
 6966  96 
         return retval;
 6967   
     }
 6968   
     // $ANTLR end "delete"
 6969   
 
 6970  24 
 
 6971  24 
     public static class deleteData_return extends ParserRuleReturnScope {
 6972   
         Object tree;
 6973  48 
         public Object getTree() { return tree; }
 6974   
     };
 6975   
 
 6976  12 
 
 6977   
     // $ANTLR start "deleteData"
 6978  12 
     // com\\googlecode\\sparkleg\\Sparql.g:251:1: deleteData : DATA quadPattern -> ^( DELETE DATA quadPattern ) ;
 6979   
     public final SparqlParser.deleteData_return deleteData() throws RecognitionException {
 6980  48 
         SparqlParser.deleteData_return retval = new SparqlParser.deleteData_return();
 6981  48 
         retval.start = input.LT(1);
 6982   
 
 6983   
 
 6984  48 
         Object root_0 = null;
 6985  12 
 
 6986  60 
         Token DATA153=null;
 6987  48 
         SparqlParser.quadPattern_return quadPattern154 =null;
 6988   
 
 6989  12 
 
 6990  48 
         Object DATA153_tree=null;
 6991  60 
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6992  60 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6993   
         try {
 6994   
             // com\\googlecode\\sparkleg\\Sparql.g:252:5: ( DATA quadPattern -> ^( DELETE DATA quadPattern ) )
 6995  12 
             // com\\googlecode\\sparkleg\\Sparql.g:252:7: DATA quadPattern
 6996  12 
             {
 6997  60 
             DATA153=(Token)match(input,DATA,FOLLOW_DATA_in_deleteData1924);
 6998  48 
             stream_DATA.add(DATA153);
 6999   
 
 7000   
 
 7001  48 
             pushFollow(FOLLOW_quadPattern_in_deleteData1926);
 7002  60 
             quadPattern154=quadPattern();
 7003  12 
 
 7004  48 
             state._fsp--;
 7005   
 
 7006  60 
             stream_quadPattern.add(quadPattern154.getTree());
 7007  12 
 
 7008   
             // AST REWRITE
 7009  12 
             // elements: quadPattern, DATA
 7010   
             // token labels:
 7011  12 
             // rule labels: retval
 7012   
             // token list labels:
 7013   
             // rule list labels:
 7014   
             // wildcard labels:
 7015  48 
             retval.tree = root_0;
 7016  48 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7017   
 
 7018  48 
             root_0 = (Object)adaptor.nil();
 7019   
             // 252:24: -> ^( DELETE DATA quadPattern )
 7020  12 
             {
 7021  12 
                 // com\\googlecode\\sparkleg\\Sparql.g:252:27: ^( DELETE DATA quadPattern )
 7022   
                 {
 7023  60 
                 Object root_1 = (Object)adaptor.nil();
 7024  48 
                 root_1 = (Object)adaptor.becomeRoot(
 7025   
                 (Object)adaptor.create(DELETE, "DELETE")
 7026   
                 , root_1);
 7027   
 
 7028  60 
                 adaptor.addChild(root_1,
 7029  12 
                 stream_DATA.nextNode()
 7030   
                 );
 7031   
 
 7032  48 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7033  12 
 
 7034  48 
                 adaptor.addChild(root_0, root_1);
 7035   
                 }
 7036   
 
 7037  12 
             }
 7038   
 
 7039  12 
 
 7040  48 
             retval.tree = root_0;
 7041   
 
 7042   
             }
 7043   
 
 7044  48 
             retval.stop = input.LT(-1);
 7045  12 
 
 7046   
 
 7047  48 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7048  48 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7049  12 
 
 7050   
         }
 7051  0 
         catch (RecognitionException re) {
 7052  12 
             reportError(re);
 7053  12 
             recover(input,re);
 7054  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7055   
 
 7056   
         }
 7057   
 
 7058  0 
         finally {
 7059   
                 // do for sure before leaving
 7060  48 
         }
 7061  48 
         return retval;
 7062   
     }
 7063   
     // $ANTLR end "deleteData"
 7064   
 
 7065  12 
 
 7066  12 
     public static class deleteWhere_return extends ParserRuleReturnScope {
 7067   
         Object tree;
 7068  48 
         public Object getTree() { return tree; }
 7069   
     };
 7070   
 
 7071  12 
 
 7072   
     // $ANTLR start "deleteWhere"
 7073  12 
     // com\\googlecode\\sparkleg\\Sparql.g:255:1: deleteWhere : WHERE quadPattern -> ^( DELETE WHERE quadPattern ) ;
 7074   
     public final SparqlParser.deleteWhere_return deleteWhere() throws RecognitionException {
 7075  48 
         SparqlParser.deleteWhere_return retval = new SparqlParser.deleteWhere_return();
 7076  48 
         retval.start = input.LT(1);
 7077   
 
 7078   
 
 7079  48 
         Object root_0 = null;
 7080  12 
 
 7081  60 
         Token WHERE155=null;
 7082  48 
         SparqlParser.quadPattern_return quadPattern156 =null;
 7083   
 
 7084  12 
 
 7085  48 
         Object WHERE155_tree=null;
 7086  60 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7087  60 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7088   
         try {
 7089   
             // com\\googlecode\\sparkleg\\Sparql.g:256:5: ( WHERE quadPattern -> ^( DELETE WHERE quadPattern ) )
 7090  12 
             // com\\googlecode\\sparkleg\\Sparql.g:256:7: WHERE quadPattern
 7091  12 
             {
 7092  60 
             WHERE155=(Token)match(input,WHERE,FOLLOW_WHERE_in_deleteWhere1953);
 7093  48 
             stream_WHERE.add(WHERE155);
 7094   
 
 7095   
 
 7096  48 
             pushFollow(FOLLOW_quadPattern_in_deleteWhere1955);
 7097  60 
             quadPattern156=quadPattern();
 7098  12 
 
 7099  48 
             state._fsp--;
 7100   
 
 7101  60 
             stream_quadPattern.add(quadPattern156.getTree());
 7102  12 
 
 7103   
             // AST REWRITE
 7104  12 
             // elements: quadPattern, WHERE
 7105   
             // token labels:
 7106  12 
             // rule labels: retval
 7107   
             // token list labels:
 7108   
             // rule list labels:
 7109   
             // wildcard labels:
 7110  48 
             retval.tree = root_0;
 7111  48 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7112   
 
 7113  48 
             root_0 = (Object)adaptor.nil();
 7114   
             // 256:25: -> ^( DELETE WHERE quadPattern )
 7115  12 
             {
 7116  12 
                 // com\\googlecode\\sparkleg\\Sparql.g:256:28: ^( DELETE WHERE quadPattern )
 7117   
                 {
 7118  60 
                 Object root_1 = (Object)adaptor.nil();
 7119  48 
                 root_1 = (Object)adaptor.becomeRoot(
 7120   
                 (Object)adaptor.create(DELETE, "DELETE")
 7121   
                 , root_1);
 7122   
 
 7123  60 
                 adaptor.addChild(root_1,
 7124  12 
                 stream_WHERE.nextNode()
 7125   
                 );
 7126   
 
 7127  48 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7128  12 
 
 7129  48 
                 adaptor.addChild(root_0, root_1);
 7130   
                 }
 7131   
 
 7132  12 
             }
 7133   
 
 7134  12 
 
 7135  48 
             retval.tree = root_0;
 7136   
 
 7137   
             }
 7138   
 
 7139  48 
             retval.stop = input.LT(-1);
 7140  12 
 
 7141   
 
 7142  48 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7143  48 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7144  12 
 
 7145   
         }
 7146  0 
         catch (RecognitionException re) {
 7147  12 
             reportError(re);
 7148  12 
             recover(input,re);
 7149  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7150   
 
 7151   
         }
 7152   
 
 7153  0 
         finally {
 7154   
                 // do for sure before leaving
 7155  48 
         }
 7156  48 
         return retval;
 7157   
     }
 7158   
     // $ANTLR end "deleteWhere"
 7159   
 
 7160  12 
 
 7161  12 
     public static class modify_return extends ParserRuleReturnScope {
 7162   
         Object tree;
 7163  320 
         public Object getTree() { return tree; }
 7164   
     };
 7165   
 
 7166  80 
 
 7167   
     // $ANTLR start "modify"
 7168  80 
     // com\\googlecode\\sparkleg\\Sparql.g:259:1: modify : ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) ;
 7169   
     public final SparqlParser.modify_return modify() throws RecognitionException {
 7170  320 
         SparqlParser.modify_return retval = new SparqlParser.modify_return();
 7171  320 
         retval.start = input.LT(1);
 7172   
 
 7173   
 
 7174  320 
         Object root_0 = null;
 7175  80 
 
 7176  400 
         Token WITH157=null;
 7177  320 
         Token WHERE163=null;
 7178  320 
         SparqlParser.iriRef_return iriRef158 =null;
 7179  80 
 
 7180  320 
         SparqlParser.deleteClause_return deleteClause159 =null;
 7181  80 
 
 7182  400 
         SparqlParser.insertClause_return insertClause160 =null;
 7183  80 
 
 7184  320 
         SparqlParser.insertClause_return insertClause161 =null;
 7185  80 
 
 7186  320 
         SparqlParser.usingClause_return usingClause162 =null;
 7187  80 
 
 7188  320 
         SparqlParser.groupGraphPattern_return groupGraphPattern164 =null;
 7189  80 
 
 7190   
 
 7191  400 
         Object WITH157_tree=null;
 7192  320 
         Object WHERE163_tree=null;
 7193  400 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7194  320 
         RewriteRuleTokenStream stream_WITH=new RewriteRuleTokenStream(adaptor,"token WITH");
 7195  320 
         RewriteRuleSubtreeStream stream_deleteClause=new RewriteRuleSubtreeStream(adaptor,"rule deleteClause");
 7196  400 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 7197  400 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7198  400 
         RewriteRuleSubtreeStream stream_insertClause=new RewriteRuleSubtreeStream(adaptor,"rule insertClause");
 7199  400 
         RewriteRuleSubtreeStream stream_usingClause=new RewriteRuleSubtreeStream(adaptor,"rule usingClause");
 7200  80 
         try {
 7201  80 
             // com\\googlecode\\sparkleg\\Sparql.g:260:5: ( ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) )
 7202  80 
             // com\\googlecode\\sparkleg\\Sparql.g:260:7: ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern
 7203  80 
             {
 7204  80 
             // com\\googlecode\\sparkleg\\Sparql.g:260:7: ( WITH iriRef )?
 7205  320 
             int alt51=2;
 7206  320 
             switch ( input.LA(1) ) {
 7207   
                 case WITH:
 7208   
                     {
 7209  56 
                     alt51=1;
 7210  80 
                     }
 7211  80 
                     break;
 7212   
             }
 7213   
 
 7214  334 
             switch (alt51) {
 7215   
                 case 1 :
 7216   
                     // com\\googlecode\\sparkleg\\Sparql.g:260:8: WITH iriRef
 7217   
                     {
 7218  56 
                     WITH157=(Token)match(input,WITH,FOLLOW_WITH_in_modify1987);
 7219  136 
                     stream_WITH.add(WITH157);
 7220   
 
 7221   
 
 7222  56 
                     pushFollow(FOLLOW_iriRef_in_modify1989);
 7223  70 
                     iriRef158=iriRef();
 7224  14 
 
 7225  56 
                     state._fsp--;
 7226   
 
 7227  70 
                     stream_iriRef.add(iriRef158.getTree());
 7228  14 
 
 7229   
                     }
 7230  14 
                     break;
 7231   
 
 7232  14 
             }
 7233   
 
 7234   
 
 7235   
             // com\\googlecode\\sparkleg\\Sparql.g:260:22: ( deleteClause ( insertClause )? | insertClause )
 7236  320 
             int alt53=2;
 7237  320 
             switch ( input.LA(1) ) {
 7238   
             case DELETE:
 7239   
                 {
 7240  264 
                 alt53=1;
 7241  80 
                 }
 7242  344 
                 break;
 7243   
             case INSERT:
 7244   
                 {
 7245  122 
                 alt53=2;
 7246   
                 }
 7247  122 
                 break;
 7248   
             default:
 7249  0 
                 NoViableAltException nvae =
 7250  14 
                     new NoViableAltException("", 53, 0, input);
 7251   
 
 7252  14 
                 throw nvae;
 7253   
 
 7254   
             }
 7255   
 
 7256  320 
             switch (alt53) {
 7257   
                 case 1 :
 7258   
                     // com\\googlecode\\sparkleg\\Sparql.g:260:23: deleteClause ( insertClause )?
 7259   
                     {
 7260  264 
                     pushFollow(FOLLOW_deleteClause_in_modify1994);
 7261  344 
                     deleteClause159=deleteClause();
 7262   
 
 7263  264 
                     state._fsp--;
 7264   
 
 7265  330 
                     stream_deleteClause.add(deleteClause159.getTree());
 7266  66 
 
 7267   
                     // com\\googlecode\\sparkleg\\Sparql.g:260:36: ( insertClause )?
 7268  330 
                     int alt52=2;
 7269  264 
                     switch ( input.LA(1) ) {
 7270  66 
                         case INSERT:
 7271   
                             {
 7272  40 
                             alt52=1;
 7273  66 
                             }
 7274  66 
                             break;
 7275   
                     }
 7276   
 
 7277  274 
                     switch (alt52) {
 7278   
                         case 1 :
 7279   
                             // com\\googlecode\\sparkleg\\Sparql.g:260:36: insertClause
 7280   
                             {
 7281  40 
                             pushFollow(FOLLOW_insertClause_in_modify1996);
 7282  106 
                             insertClause160=insertClause();
 7283   
 
 7284  40 
                             state._fsp--;
 7285   
 
 7286  50 
                             stream_insertClause.add(insertClause160.getTree());
 7287  10 
 
 7288   
                             }
 7289  10 
                             break;
 7290   
 
 7291  10 
                     }
 7292   
 
 7293   
 
 7294   
                     }
 7295  264 
                     break;
 7296   
                 case 2 :
 7297   
                     // com\\googlecode\\sparkleg\\Sparql.g:260:52: insertClause
 7298   
                     {
 7299  56 
                     pushFollow(FOLLOW_insertClause_in_modify2001);
 7300  122 
                     insertClause161=insertClause();
 7301   
 
 7302  56 
                     state._fsp--;
 7303   
 
 7304  70 
                     stream_insertClause.add(insertClause161.getTree());
 7305  14 
 
 7306   
                     }
 7307  14 
                     break;
 7308   
 
 7309  14 
             }
 7310   
 
 7311   
 
 7312   
             // com\\googlecode\\sparkleg\\Sparql.g:260:66: ( usingClause )*
 7313   
             loop54:
 7314   
             do {
 7315  383 
                 int alt54=2;
 7316  383 
                 switch ( input.LA(1) ) {
 7317   
                 case USING:
 7318   
                     {
 7319  63 
                     alt54=1;
 7320  98 
                     }
 7321  98 
                     break;
 7322   
 
 7323   
                 }
 7324  18 
 
 7325  383 
                 switch (alt54) {
 7326   
                     case 1 :
 7327   
                         // com\\googlecode\\sparkleg\\Sparql.g:260:66: usingClause
 7328   
                         {
 7329  63 
                         pushFollow(FOLLOW_usingClause_in_modify2004);
 7330  161 
                         usingClause162=usingClause();
 7331   
 
 7332  63 
                         state._fsp--;
 7333   
 
 7334  81 
                         stream_usingClause.add(usingClause162.getTree());
 7335  18 
 
 7336   
                         }
 7337  81 
                         break;
 7338   
 
 7339  18 
                     default :
 7340  320 
                         break loop54;
 7341   
                 }
 7342  81 
             } while (true);
 7343   
 
 7344   
 
 7345  400 
             WHERE163=(Token)match(input,WHERE,FOLLOW_WHERE_in_modify2007);
 7346  320 
             stream_WHERE.add(WHERE163);
 7347  18 
 
 7348   
 
 7349  320 
             pushFollow(FOLLOW_groupGraphPattern_in_modify2009);
 7350  400 
             groupGraphPattern164=groupGraphPattern();
 7351  80 
 
 7352  320 
             state._fsp--;
 7353   
 
 7354  400 
             stream_groupGraphPattern.add(groupGraphPattern164.getTree());
 7355  80 
 
 7356   
             // AST REWRITE
 7357  80 
             // elements: deleteClause, insertClause, WITH, groupGraphPattern, iriRef, usingClause
 7358   
             // token labels:
 7359  80 
             // rule labels: retval
 7360   
             // token list labels:
 7361   
             // rule list labels:
 7362   
             // wildcard labels:
 7363  320 
             retval.tree = root_0;
 7364  320 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7365   
 
 7366  320 
             root_0 = (Object)adaptor.nil();
 7367   
             // 260:103: -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7368  80 
             {
 7369  80 
                 // com\\googlecode\\sparkleg\\Sparql.g:260:106: ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7370   
                 {
 7371  400 
                 Object root_1 = (Object)adaptor.nil();
 7372  320 
                 root_1 = (Object)adaptor.becomeRoot(
 7373   
                 (Object)adaptor.create(MODIFY, "MODIFY")
 7374   
                 , root_1);
 7375   
 
 7376  80 
                 // com\\googlecode\\sparkleg\\Sparql.g:260:115: ( WITH iriRef )?
 7377  400 
                 if ( stream_WITH.hasNext()||stream_iriRef.hasNext() ) {
 7378  56 
                     adaptor.addChild(root_1,
 7379   
                     stream_WITH.nextNode()
 7380   
                     );
 7381   
 
 7382  136 
                     adaptor.addChild(root_1, stream_iriRef.nextTree());
 7383   
 
 7384   
                 }
 7385  334 
                 stream_WITH.reset();
 7386  334 
                 stream_iriRef.reset();
 7387   
 
 7388   
                 // com\\googlecode\\sparkleg\\Sparql.g:260:130: ( deleteClause )*
 7389  584 
                 while ( stream_deleteClause.hasNext() ) {
 7390  278 
                     adaptor.addChild(root_1, stream_deleteClause.nextTree());
 7391   
 
 7392  14 
                 }
 7393  320 
                 stream_deleteClause.reset();
 7394   
 
 7395   
                 // com\\googlecode\\sparkleg\\Sparql.g:260:144: ( insertClause )*
 7396  496 
                 while ( stream_insertClause.hasNext() ) {
 7397  176 
                     adaptor.addChild(root_1, stream_insertClause.nextTree());
 7398   
 
 7399   
                 }
 7400  466 
                 stream_insertClause.reset();
 7401  66 
 
 7402   
                 // com\\googlecode\\sparkleg\\Sparql.g:260:158: ( usingClause )*
 7403  383 
                 while ( stream_usingClause.hasNext() ) {
 7404  143 
                     adaptor.addChild(root_1, stream_usingClause.nextTree());
 7405   
 
 7406   
                 }
 7407  424 
                 stream_usingClause.reset();
 7408  24 
 
 7409   
                 // com\\googlecode\\sparkleg\\Sparql.g:260:171: ^( WHERE_CLAUSE groupGraphPattern )
 7410   
                 {
 7411  400 
                 Object root_2 = (Object)adaptor.nil();
 7412  320 
                 root_2 = (Object)adaptor.becomeRoot(
 7413   
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 7414  98 
                 , root_2);
 7415  18 
 
 7416  320 
                 adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 7417   
 
 7418  400 
                 adaptor.addChild(root_1, root_2);
 7419   
                 }
 7420   
 
 7421  320 
                 adaptor.addChild(root_0, root_1);
 7422  80 
                 }
 7423  80 
 
 7424   
             }
 7425   
 
 7426   
 
 7427  400 
             retval.tree = root_0;
 7428   
 
 7429  80 
             }
 7430   
 
 7431  320 
             retval.stop = input.LT(-1);
 7432  80 
 
 7433   
 
 7434  320 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7435  320 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7436   
 
 7437   
         }
 7438  80 
         catch (RecognitionException re) {
 7439  0 
             reportError(re);
 7440  0 
             recover(input,re);
 7441  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7442  80 
 
 7443   
         }
 7444   
 
 7445  80 
         finally {
 7446  80 
                 // do for sure before leaving
 7447  320 
         }
 7448  320 
         return retval;
 7449   
     }
 7450   
     // $ANTLR end "modify"
 7451   
 
 7452   
 
 7453  264 
     public static class deleteClause_return extends ParserRuleReturnScope {
 7454   
         Object tree;
 7455  264 
         public Object getTree() { return tree; }
 7456   
     };
 7457   
 
 7458  80 
 
 7459  80 
     // $ANTLR start "deleteClause"
 7460   
     // com\\googlecode\\sparkleg\\Sparql.g:263:1: deleteClause : DELETE quadPattern -> ^( DELETE quadPattern ) ;
 7461   
     public final SparqlParser.deleteClause_return deleteClause() throws RecognitionException {
 7462  264 
         SparqlParser.deleteClause_return retval = new SparqlParser.deleteClause_return();
 7463  264 
         retval.start = input.LT(1);
 7464  66 
 
 7465   
 
 7466  264 
         Object root_0 = null;
 7467   
 
 7468  264 
         Token DELETE165=null;
 7469  264 
         SparqlParser.quadPattern_return quadPattern166 =null;
 7470   
 
 7471   
 
 7472  264 
         Object DELETE165_tree=null;
 7473  330 
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 7474  330 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7475   
         try {
 7476   
             // com\\googlecode\\sparkleg\\Sparql.g:264:5: ( DELETE quadPattern -> ^( DELETE quadPattern ) )
 7477  66 
             // com\\googlecode\\sparkleg\\Sparql.g:264:7: DELETE quadPattern
 7478   
             {
 7479  330 
             DELETE165=(Token)match(input,DELETE,FOLLOW_DELETE_in_deleteClause2056);
 7480  330 
             stream_DELETE.add(DELETE165);
 7481   
 
 7482   
 
 7483  330 
             pushFollow(FOLLOW_quadPattern_in_deleteClause2058);
 7484  330 
             quadPattern166=quadPattern();
 7485  66 
 
 7486  264 
             state._fsp--;
 7487   
 
 7488  264 
             stream_quadPattern.add(quadPattern166.getTree());
 7489   
 
 7490  66 
             // AST REWRITE
 7491  66 
             // elements: DELETE, quadPattern
 7492   
             // token labels:
 7493   
             // rule labels: retval
 7494  66 
             // token list labels:
 7495  66 
             // rule list labels:
 7496   
             // wildcard labels:
 7497  330 
             retval.tree = root_0;
 7498  264 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7499  66 
 
 7500  264 
             root_0 = (Object)adaptor.nil();
 7501   
             // 264:26: -> ^( DELETE quadPattern )
 7502   
             {
 7503   
                 // com\\googlecode\\sparkleg\\Sparql.g:264:29: ^( DELETE quadPattern )
 7504   
                 {
 7505  264 
                 Object root_1 = (Object)adaptor.nil();
 7506  264 
                 root_1 = (Object)adaptor.becomeRoot(
 7507   
                 stream_DELETE.nextNode()
 7508  66 
                 , root_1);
 7509  66 
 
 7510  264 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7511  66 
 
 7512  264 
                 adaptor.addChild(root_0, root_1);
 7513   
                 }
 7514   
 
 7515   
             }
 7516  66 
 
 7517  66 
 
 7518  264 
             retval.tree = root_0;
 7519   
 
 7520   
             }
 7521  66 
 
 7522  264 
             retval.stop = input.LT(-1);
 7523  66 
 
 7524   
 
 7525  264 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7526  264 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7527   
 
 7528   
         }
 7529  66 
         catch (RecognitionException re) {
 7530  0 
             reportError(re);
 7531  0 
             recover(input,re);
 7532  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7533  66 
 
 7534   
         }
 7535   
 
 7536  66 
         finally {
 7537  66 
                 // do for sure before leaving
 7538  264 
         }
 7539  264 
         return retval;
 7540   
     }
 7541   
     // $ANTLR end "deleteClause"
 7542   
 
 7543   
 
 7544  96 
     public static class insertClause_return extends ParserRuleReturnScope {
 7545   
         Object tree;
 7546  96 
         public Object getTree() { return tree; }
 7547   
     };
 7548   
 
 7549  66 
 
 7550  66 
     // $ANTLR start "insertClause"
 7551   
     // com\\googlecode\\sparkleg\\Sparql.g:267:1: insertClause : INSERT quadPattern -> ^( INSERT quadPattern ) ;
 7552   
     public final SparqlParser.insertClause_return insertClause() throws RecognitionException {
 7553  96 
         SparqlParser.insertClause_return retval = new SparqlParser.insertClause_return();
 7554  96 
         retval.start = input.LT(1);
 7555  24 
 
 7556   
 
 7557  96 
         Object root_0 = null;
 7558   
 
 7559  96 
         Token INSERT167=null;
 7560  96 
         SparqlParser.quadPattern_return quadPattern168 =null;
 7561   
 
 7562   
 
 7563  96 
         Object INSERT167_tree=null;
 7564  120 
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 7565  120 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7566   
         try {
 7567   
             // com\\googlecode\\sparkleg\\Sparql.g:268:5: ( INSERT quadPattern -> ^( INSERT quadPattern ) )
 7568  24 
             // com\\googlecode\\sparkleg\\Sparql.g:268:7: INSERT quadPattern
 7569   
             {
 7570  120 
             INSERT167=(Token)match(input,INSERT,FOLLOW_INSERT_in_insertClause2089);
 7571  120 
             stream_INSERT.add(INSERT167);
 7572   
 
 7573   
 
 7574  120 
             pushFollow(FOLLOW_quadPattern_in_insertClause2091);
 7575  120 
             quadPattern168=quadPattern();
 7576  24 
 
 7577  96 
             state._fsp--;
 7578   
 
 7579  96 
             stream_quadPattern.add(quadPattern168.getTree());
 7580   
 
 7581  24 
             // AST REWRITE
 7582  24 
             // elements: INSERT, quadPattern
 7583   
             // token labels:
 7584   
             // rule labels: retval
 7585  24 
             // token list labels:
 7586  24 
             // rule list labels:
 7587   
             // wildcard labels:
 7588  120 
             retval.tree = root_0;
 7589  96 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7590  24 
 
 7591  96 
             root_0 = (Object)adaptor.nil();
 7592   
             // 268:26: -> ^( INSERT quadPattern )
 7593   
             {
 7594   
                 // com\\googlecode\\sparkleg\\Sparql.g:268:29: ^( INSERT quadPattern )
 7595   
                 {
 7596  96 
                 Object root_1 = (Object)adaptor.nil();
 7597  96 
                 root_1 = (Object)adaptor.becomeRoot(
 7598   
                 stream_INSERT.nextNode()
 7599  24 
                 , root_1);
 7600  24 
 
 7601  96 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7602  24 
 
 7603  96 
                 adaptor.addChild(root_0, root_1);
 7604   
                 }
 7605   
 
 7606   
             }
 7607  24 
 
 7608  24 
 
 7609  96 
             retval.tree = root_0;
 7610   
 
 7611   
             }
 7612  24 
 
 7613  96 
             retval.stop = input.LT(-1);
 7614  24 
 
 7615   
 
 7616  96 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7617  96 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7618   
 
 7619   
         }
 7620  24 
         catch (RecognitionException re) {
 7621  0 
             reportError(re);
 7622  0 
             recover(input,re);
 7623  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7624  24 
 
 7625   
         }
 7626   
 
 7627  24 
         finally {
 7628  24 
                 // do for sure before leaving
 7629  96 
         }
 7630  96 
         return retval;
 7631   
     }
 7632   
     // $ANTLR end "insertClause"
 7633   
 
 7634   
 
 7635  63 
     public static class usingClause_return extends ParserRuleReturnScope {
 7636   
         Object tree;
 7637  63 
         public Object getTree() { return tree; }
 7638   
     };
 7639   
 
 7640  24 
 
 7641  24 
     // $ANTLR start "usingClause"
 7642   
     // com\\googlecode\\sparkleg\\Sparql.g:271:1: usingClause : USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) ;
 7643   
     public final SparqlParser.usingClause_return usingClause() throws RecognitionException {
 7644  63 
         SparqlParser.usingClause_return retval = new SparqlParser.usingClause_return();
 7645  63 
         retval.start = input.LT(1);
 7646  18 
 
 7647   
 
 7648  63 
         Object root_0 = null;
 7649   
 
 7650  63 
         Token USING169=null;
 7651  63 
         Token NAMED170=null;
 7652  63 
         SparqlParser.iriRef_return iriRef171 =null;
 7653   
 
 7654   
 
 7655  81 
         Object USING169_tree=null;
 7656  81 
         Object NAMED170_tree=null;
 7657  63 
         RewriteRuleTokenStream stream_USING=new RewriteRuleTokenStream(adaptor,"token USING");
 7658  63 
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 7659  81 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7660   
         try {
 7661  18 
             // com\\googlecode\\sparkleg\\Sparql.g:272:5: ( USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) )
 7662  18 
             // com\\googlecode\\sparkleg\\Sparql.g:272:7: USING ( NAMED )? iriRef
 7663  18 
             {
 7664  63 
             USING169=(Token)match(input,USING,FOLLOW_USING_in_usingClause2116);
 7665  63 
             stream_USING.add(USING169);
 7666  18 
 
 7667  18 
 
 7668  18 
             // com\\googlecode\\sparkleg\\Sparql.g:272:13: ( NAMED )?
 7669  81 
             int alt55=2;
 7670  81 
             switch ( input.LA(1) ) {
 7671   
                 case NAMED:
 7672   
                     {
 7673  0 
                     alt55=1;
 7674   
                     }
 7675  18 
                     break;
 7676  18 
             }
 7677   
 
 7678  63 
             switch (alt55) {
 7679   
                 case 1 :
 7680  18 
                     // com\\googlecode\\sparkleg\\Sparql.g:272:13: NAMED
 7681  18 
                     {
 7682  0 
                     NAMED170=(Token)match(input,NAMED,FOLLOW_NAMED_in_usingClause2118);
 7683  0 
                     stream_NAMED.add(NAMED170);
 7684   
 
 7685   
 
 7686   
                     }
 7687   
                     break;
 7688   
 
 7689  18 
             }
 7690   
 
 7691   
 
 7692  63 
             pushFollow(FOLLOW_iriRef_in_usingClause2121);
 7693  63 
             iriRef171=iriRef();
 7694   
 
 7695  63 
             state._fsp--;
 7696   
 
 7697  63 
             stream_iriRef.add(iriRef171.getTree());
 7698   
 
 7699   
             // AST REWRITE
 7700   
             // elements: USING, NAMED, iriRef
 7701   
             // token labels:
 7702   
             // rule labels: retval
 7703  18 
             // token list labels:
 7704  18 
             // rule list labels:
 7705   
             // wildcard labels:
 7706  81 
             retval.tree = root_0;
 7707  63 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7708  18 
 
 7709  63 
             root_0 = (Object)adaptor.nil();
 7710   
             // 272:27: -> ^( USING ( NAMED )? iriRef )
 7711   
             {
 7712   
                 // com\\googlecode\\sparkleg\\Sparql.g:272:30: ^( USING ( NAMED )? iriRef )
 7713   
                 {
 7714  63 
                 Object root_1 = (Object)adaptor.nil();
 7715  63 
                 root_1 = (Object)adaptor.becomeRoot(
 7716   
                 stream_USING.nextNode()
 7717  18 
                 , root_1);
 7718  18 
 
 7719   
                 // com\\googlecode\\sparkleg\\Sparql.g:272:38: ( NAMED )?
 7720  81 
                 if ( stream_NAMED.hasNext() ) {
 7721  0 
                     adaptor.addChild(root_1,
 7722   
                     stream_NAMED.nextNode()
 7723   
                     );
 7724   
 
 7725  18 
                 }
 7726  81 
                 stream_NAMED.reset();
 7727   
 
 7728  63 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 7729   
 
 7730  63 
                 adaptor.addChild(root_0, root_1);
 7731  18 
                 }
 7732   
 
 7733   
             }
 7734   
 
 7735   
 
 7736  63 
             retval.tree = root_0;
 7737  18 
 
 7738   
             }
 7739  18 
 
 7740  63 
             retval.stop = input.LT(-1);
 7741  18 
 
 7742   
 
 7743  63 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7744  63 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7745   
 
 7746   
         }
 7747  18 
         catch (RecognitionException re) {
 7748  0 
             reportError(re);
 7749  0 
             recover(input,re);
 7750  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7751  18 
 
 7752   
         }
 7753   
 
 7754  18 
         finally {
 7755  18 
                 // do for sure before leaving
 7756  63 
         }
 7757  63 
         return retval;
 7758   
     }
 7759   
     // $ANTLR end "usingClause"
 7760   
 
 7761   
 
 7762  0 
     public static class graphOrDefault_return extends ParserRuleReturnScope {
 7763   
         Object tree;
 7764  0 
         public Object getTree() { return tree; }
 7765   
     };
 7766   
 
 7767  18 
 
 7768  18 
     // $ANTLR start "graphOrDefault"
 7769   
     // com\\googlecode\\sparkleg\\Sparql.g:275:1: graphOrDefault : ( DEFAULT | ( GRAPH )? iriRef );
 7770   
     public final SparqlParser.graphOrDefault_return graphOrDefault() throws RecognitionException {
 7771  0 
         SparqlParser.graphOrDefault_return retval = new SparqlParser.graphOrDefault_return();
 7772  0 
         retval.start = input.LT(1);
 7773   
 
 7774   
 
 7775  0 
         Object root_0 = null;
 7776   
 
 7777  0 
         Token DEFAULT172=null;
 7778  0 
         Token GRAPH173=null;
 7779  0 
         SparqlParser.iriRef_return iriRef174 =null;
 7780   
 
 7781   
 
 7782  0 
         Object DEFAULT172_tree=null;
 7783  0 
         Object GRAPH173_tree=null;
 7784   
 
 7785   
         try {
 7786   
             // com\\googlecode\\sparkleg\\Sparql.g:276:5: ( DEFAULT | ( GRAPH )? iriRef )
 7787  0 
             int alt57=2;
 7788  0 
             switch ( input.LA(1) ) {
 7789   
             case DEFAULT:
 7790   
                 {
 7791  0 
                 alt57=1;
 7792   
                 }
 7793  0 
                 break;
 7794   
             case GRAPH:
 7795   
             case IRI_REF:
 7796   
             case PNAME_LN:
 7797   
             case PNAME_NS:
 7798   
                 {
 7799  0 
                 alt57=2;
 7800   
                 }
 7801  0 
                 break;
 7802   
             default:
 7803  0 
                 NoViableAltException nvae =
 7804   
                     new NoViableAltException("", 57, 0, input);
 7805   
 
 7806  0 
                 throw nvae;
 7807   
 
 7808   
             }
 7809   
 
 7810  0 
             switch (alt57) {
 7811   
                 case 1 :
 7812   
                     // com\\googlecode\\sparkleg\\Sparql.g:276:7: DEFAULT
 7813   
                     {
 7814  0 
                     root_0 = (Object)adaptor.nil();
 7815   
 
 7816   
 
 7817  0 
                     DEFAULT172=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphOrDefault2152);
 7818  0 
                     DEFAULT172_tree =
 7819   
                     (Object)adaptor.create(DEFAULT172)
 7820   
                     ;
 7821  0 
                     adaptor.addChild(root_0, DEFAULT172_tree);
 7822   
 
 7823   
 
 7824   
                     }
 7825  0 
                     break;
 7826   
                 case 2 :
 7827   
                     // com\\googlecode\\sparkleg\\Sparql.g:277:7: ( GRAPH )? iriRef
 7828   
                     {
 7829  0 
                     root_0 = (Object)adaptor.nil();
 7830   
 
 7831   
 
 7832   
                     // com\\googlecode\\sparkleg\\Sparql.g:277:7: ( GRAPH )?
 7833  0 
                     int alt56=2;
 7834  0 
                     switch ( input.LA(1) ) {
 7835   
                         case GRAPH:
 7836   
                             {
 7837  0 
                             alt56=1;
 7838   
                             }
 7839   
                             break;
 7840   
                     }
 7841   
 
 7842  0 
                     switch (alt56) {
 7843   
                         case 1 :
 7844   
                             // com\\googlecode\\sparkleg\\Sparql.g:277:7: GRAPH
 7845   
                             {
 7846  0 
                             GRAPH173=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphOrDefault2161);
 7847  0 
                             GRAPH173_tree =
 7848   
                             (Object)adaptor.create(GRAPH173)
 7849   
                             ;
 7850  0 
                             adaptor.addChild(root_0, GRAPH173_tree);
 7851   
 
 7852   
 
 7853   
                             }
 7854   
                             break;
 7855   
 
 7856   
                     }
 7857   
 
 7858   
 
 7859  0 
                     pushFollow(FOLLOW_iriRef_in_graphOrDefault2164);
 7860  0 
                     iriRef174=iriRef();
 7861   
 
 7862  0 
                     state._fsp--;
 7863   
 
 7864  0 
                     adaptor.addChild(root_0, iriRef174.getTree());
 7865   
 
 7866   
                     }
 7867   
                     break;
 7868   
 
 7869   
             }
 7870  0 
             retval.stop = input.LT(-1);
 7871   
 
 7872   
 
 7873  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7874  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7875   
 
 7876   
         }
 7877  0 
         catch (RecognitionException re) {
 7878  0 
             reportError(re);
 7879  0 
             recover(input,re);
 7880  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7881   
 
 7882   
         }
 7883   
 
 7884  0 
         finally {
 7885   
                 // do for sure before leaving
 7886  0 
         }
 7887  0 
         return retval;
 7888   
     }
 7889   
     // $ANTLR end "graphOrDefault"
 7890   
 
 7891   
 
 7892  16 
     public static class graphRef_return extends ParserRuleReturnScope {
 7893   
         Object tree;
 7894  16 
         public Object getTree() { return tree; }
 7895   
     };
 7896   
 
 7897   
 
 7898   
     // $ANTLR start "graphRef"
 7899   
     // com\\googlecode\\sparkleg\\Sparql.g:280:1: graphRef : GRAPH iriRef ;
 7900   
     public final SparqlParser.graphRef_return graphRef() throws RecognitionException {
 7901  16 
         SparqlParser.graphRef_return retval = new SparqlParser.graphRef_return();
 7902  16 
         retval.start = input.LT(1);
 7903  4 
 
 7904   
 
 7905  16 
         Object root_0 = null;
 7906   
 
 7907  16 
         Token GRAPH175=null;
 7908  16 
         SparqlParser.iriRef_return iriRef176 =null;
 7909   
 
 7910   
 
 7911  16 
         Object GRAPH175_tree=null;
 7912  4 
 
 7913  4 
         try {
 7914   
             // com\\googlecode\\sparkleg\\Sparql.g:281:5: ( GRAPH iriRef )
 7915   
             // com\\googlecode\\sparkleg\\Sparql.g:281:7: GRAPH iriRef
 7916  4 
             {
 7917  16 
             root_0 = (Object)adaptor.nil();
 7918  4 
 
 7919  4 
 
 7920  16 
             GRAPH175=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphRef2191);
 7921  16 
             GRAPH175_tree =
 7922  4 
             (Object)adaptor.create(GRAPH175)
 7923   
             ;
 7924  16 
             adaptor.addChild(root_0, GRAPH175_tree);
 7925   
 
 7926   
 
 7927  16 
             pushFollow(FOLLOW_iriRef_in_graphRef2193);
 7928  20 
             iriRef176=iriRef();
 7929   
 
 7930  16 
             state._fsp--;
 7931  4 
 
 7932  20 
             adaptor.addChild(root_0, iriRef176.getTree());
 7933   
 
 7934   
             }
 7935  4 
 
 7936  16 
             retval.stop = input.LT(-1);
 7937   
 
 7938  4 
 
 7939  20 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7940  16 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7941  4 
 
 7942   
         }
 7943  4 
         catch (RecognitionException re) {
 7944  0 
             reportError(re);
 7945  0 
             recover(input,re);
 7946  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7947  4 
 
 7948   
         }
 7949   
 
 7950  4 
         finally {
 7951  4 
                 // do for sure before leaving
 7952  16 
         }
 7953  16 
         return retval;
 7954   
     }
 7955   
     // $ANTLR end "graphRef"
 7956   
 
 7957   
 
 7958  64 
     public static class graphRefAll_return extends ParserRuleReturnScope {
 7959   
         Object tree;
 7960  64 
         public Object getTree() { return tree; }
 7961   
     };
 7962   
 
 7963  4 
 
 7964  4 
     // $ANTLR start "graphRefAll"
 7965   
     // com\\googlecode\\sparkleg\\Sparql.g:284:1: graphRefAll : ( graphRef | DEFAULT | NAMED | ALL );
 7966   
     public final SparqlParser.graphRefAll_return graphRefAll() throws RecognitionException {
 7967  64 
         SparqlParser.graphRefAll_return retval = new SparqlParser.graphRefAll_return();
 7968  64 
         retval.start = input.LT(1);
 7969  16 
 
 7970   
 
 7971  16 
         Object root_0 = null;
 7972   
 
 7973  64 
         Token DEFAULT178=null;
 7974  64 
         Token NAMED179=null;
 7975  64 
         Token ALL180=null;
 7976  64 
         SparqlParser.graphRef_return graphRef177 =null;
 7977   
 
 7978  16 
 
 7979  80 
         Object DEFAULT178_tree=null;
 7980  64 
         Object NAMED179_tree=null;
 7981  64 
         Object ALL180_tree=null;
 7982  16 
 
 7983   
         try {
 7984  16 
             // com\\googlecode\\sparkleg\\Sparql.g:285:5: ( graphRef | DEFAULT | NAMED | ALL )
 7985  80 
             int alt58=4;
 7986  80 
             switch ( input.LA(1) ) {
 7987  16 
             case GRAPH:
 7988   
                 {
 7989  16 
                 alt58=1;
 7990  16 
                 }
 7991  32 
                 break;
 7992  16 
             case DEFAULT:
 7993   
                 {
 7994  16 
                 alt58=2;
 7995   
                 }
 7996  32 
                 break;
 7997  16 
             case NAMED:
 7998   
                 {
 7999  16 
                 alt58=3;
 8000  4 
                 }
 8001  16 
                 break;
 8002  4 
             case ALL:
 8003   
                 {
 8004  16 
                 alt58=4;
 8005  4 
                 }
 8006  16 
                 break;
 8007  4 
             default:
 8008  0 
                 NoViableAltException nvae =
 8009   
                     new NoViableAltException("", 58, 0, input);
 8010  4 
 
 8011  0 
                 throw nvae;
 8012  4 
 
 8013   
             }
 8014   
 
 8015  68 
             switch (alt58) {
 8016   
                 case 1 :
 8017  4 
                     // com\\googlecode\\sparkleg\\Sparql.g:285:7: graphRef
 8018   
                     {
 8019  16 
                     root_0 = (Object)adaptor.nil();
 8020   
 
 8021   
 
 8022  16 
                     pushFollow(FOLLOW_graphRef_in_graphRefAll2210);
 8023  16 
                     graphRef177=graphRef();
 8024   
 
 8025  16 
                     state._fsp--;
 8026  16 
 
 8027  16 
                     adaptor.addChild(root_0, graphRef177.getTree());
 8028   
 
 8029   
                     }
 8030  20 
                     break;
 8031   
                 case 2 :
 8032   
                     // com\\googlecode\\sparkleg\\Sparql.g:285:18: DEFAULT
 8033  4 
                     {
 8034  20 
                     root_0 = (Object)adaptor.nil();
 8035   
 
 8036  4 
 
 8037  16 
                     DEFAULT178=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphRefAll2214);
 8038  20 
                     DEFAULT178_tree =
 8039   
                     (Object)adaptor.create(DEFAULT178)
 8040   
                     ;
 8041  20 
                     adaptor.addChild(root_0, DEFAULT178_tree);
 8042   
 
 8043   
 
 8044   
                     }
 8045  20 
                     break;
 8046   
                 case 3 :
 8047   
                     // com\\googlecode\\sparkleg\\Sparql.g:285:28: NAMED
 8048  4 
                     {
 8049  20 
                     root_0 = (Object)adaptor.nil();
 8050   
 
 8051   
 
 8052  20 
                     NAMED179=(Token)match(input,NAMED,FOLLOW_NAMED_in_graphRefAll2218);
 8053  16 
                     NAMED179_tree =
 8054   
                     (Object)adaptor.create(NAMED179)
 8055   
                     ;
 8056  20 
                     adaptor.addChild(root_0, NAMED179_tree);
 8057   
 
 8058   
 
 8059   
                     }
 8060  20 
                     break;
 8061   
                 case 4 :
 8062   
                     // com\\googlecode\\sparkleg\\Sparql.g:285:36: ALL
 8063  4 
                     {
 8064  20 
                     root_0 = (Object)adaptor.nil();
 8065   
 
 8066   
 
 8067  20 
                     ALL180=(Token)match(input,ALL,FOLLOW_ALL_in_graphRefAll2222);
 8068  16 
                     ALL180_tree =
 8069   
                     (Object)adaptor.create(ALL180)
 8070   
                     ;
 8071  20 
                     adaptor.addChild(root_0, ALL180_tree);
 8072   
 
 8073   
 
 8074   
                     }
 8075  4 
                     break;
 8076   
 
 8077   
             }
 8078  68 
             retval.stop = input.LT(-1);
 8079  4 
 
 8080   
 
 8081  64 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8082  68 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8083   
 
 8084   
         }
 8085  0 
         catch (RecognitionException re) {
 8086  0 
             reportError(re);
 8087  0 
             recover(input,re);
 8088  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8089  16 
 
 8090   
         }
 8091   
 
 8092  16 
         finally {
 8093  16 
                 // do for sure before leaving
 8094  64 
         }
 8095  64 
         return retval;
 8096   
     }
 8097   
     // $ANTLR end "graphRefAll"
 8098   
 
 8099   
 
 8100  488 
     public static class quadPattern_return extends ParserRuleReturnScope {
 8101   
         Object tree;
 8102  488 
         public Object getTree() { return tree; }
 8103   
     };
 8104   
 
 8105  16 
 
 8106  16 
     // $ANTLR start "quadPattern"
 8107   
     // com\\googlecode\\sparkleg\\Sparql.g:288:1: quadPattern : '{' quads '}' -> quads ;
 8108   
     public final SparqlParser.quadPattern_return quadPattern() throws RecognitionException {
 8109  488 
         SparqlParser.quadPattern_return retval = new SparqlParser.quadPattern_return();
 8110  488 
         retval.start = input.LT(1);
 8111  122 
 
 8112   
 
 8113  488 
         Object root_0 = null;
 8114   
 
 8115  488 
         Token char_literal181=null;
 8116  488 
         Token char_literal183=null;
 8117  488 
         SparqlParser.quads_return quads182 =null;
 8118   
 
 8119   
 
 8120  610 
         Object char_literal181_tree=null;
 8121  610 
         Object char_literal183_tree=null;
 8122  488 
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 8123  488 
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 8124  610 
         RewriteRuleSubtreeStream stream_quads=new RewriteRuleSubtreeStream(adaptor,"rule quads");
 8125   
         try {
 8126  122 
             // com\\googlecode\\sparkleg\\Sparql.g:289:5: ( '{' quads '}' -> quads )
 8127  122 
             // com\\googlecode\\sparkleg\\Sparql.g:289:7: '{' quads '}'
 8128  122 
             {
 8129  488 
             char_literal181=(Token)match(input,216,FOLLOW_216_in_quadPattern2239);
 8130  488 
             stream_216.add(char_literal181);
 8131  122 
 
 8132  122 
 
 8133  610 
             pushFollow(FOLLOW_quads_in_quadPattern2241);
 8134  610 
             quads182=quads();
 8135  122 
 
 8136  488 
             state._fsp--;
 8137   
 
 8138  488 
             stream_quads.add(quads182.getTree());
 8139   
 
 8140  610 
             char_literal183=(Token)match(input,218,FOLLOW_218_in_quadPattern2243);
 8141  610 
             stream_218.add(char_literal183);
 8142   
 
 8143   
 
 8144  122 
             // AST REWRITE
 8145  122 
             // elements: quads
 8146   
             // token labels:
 8147  122 
             // rule labels: retval
 8148   
             // token list labels:
 8149  122 
             // rule list labels:
 8150   
             // wildcard labels:
 8151  610 
             retval.tree = root_0;
 8152  610 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8153   
 
 8154  488 
             root_0 = (Object)adaptor.nil();
 8155   
             // 289:21: -> quads
 8156   
             {
 8157  488 
                 adaptor.addChild(root_0, stream_quads.nextTree());
 8158   
 
 8159   
             }
 8160   
 
 8161   
 
 8162  610 
             retval.tree = root_0;
 8163  122 
 
 8164   
             }
 8165  122 
 
 8166  488 
             retval.stop = input.LT(-1);
 8167   
 
 8168  122 
 
 8169  488 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8170  488 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8171   
 
 8172   
         }
 8173  122 
         catch (RecognitionException re) {
 8174  0 
             reportError(re);
 8175  0 
             recover(input,re);
 8176  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8177  122 
 
 8178   
         }
 8179   
 
 8180  122 
         finally {
 8181  122 
                 // do for sure before leaving
 8182  488 
         }
 8183  488 
         return retval;
 8184   
     }
 8185   
     // $ANTLR end "quadPattern"
 8186   
 
 8187   
 
 8188  488 
     public static class quads_return extends ParserRuleReturnScope {
 8189   
         Object tree;
 8190  488 
         public Object getTree() { return tree; }
 8191   
     };
 8192   
 
 8193  122 
 
 8194  122 
     // $ANTLR start "quads"
 8195   
     // com\\googlecode\\sparkleg\\Sparql.g:292:1: quads : ( triplesTemplate )? ( quadsDetails )* -> ( triplesTemplate )? ( quadsDetails )* ;
 8196   
     public final SparqlParser.quads_return quads() throws RecognitionException {
 8197  488 
         SparqlParser.quads_return retval = new SparqlParser.quads_return();
 8198  488 
         retval.start = input.LT(1);
 8199  122 
 
 8200   
 
 8201  488 
         Object root_0 = null;
 8202   
 
 8203  488 
         SparqlParser.triplesTemplate_return triplesTemplate184 =null;
 8204   
 
 8205  488 
         SparqlParser.quadsDetails_return quadsDetails185 =null;
 8206   
 
 8207   
 
 8208  610 
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8209  610 
         RewriteRuleSubtreeStream stream_quadsDetails=new RewriteRuleSubtreeStream(adaptor,"rule quadsDetails");
 8210   
         try {
 8211   
             // com\\googlecode\\sparkleg\\Sparql.g:293:5: ( ( triplesTemplate )? ( quadsDetails )* -> ( triplesTemplate )? ( quadsDetails )* )
 8212  122 
             // com\\googlecode\\sparkleg\\Sparql.g:293:7: ( triplesTemplate )? ( quadsDetails )*
 8213   
             {
 8214  122 
             // com\\googlecode\\sparkleg\\Sparql.g:293:7: ( triplesTemplate )?
 8215  488 
             int alt59=2;
 8216  610 
             switch ( input.LA(1) ) {
 8217   
                 case BLANK_NODE_LABEL:
 8218   
                 case DECIMAL:
 8219  122 
                 case DECIMAL_NEGATIVE:
 8220  122 
                 case DECIMAL_POSITIVE:
 8221   
                 case DOUBLE:
 8222   
                 case DOUBLE_NEGATIVE:
 8223   
                 case DOUBLE_POSITIVE:
 8224   
                 case FALSE:
 8225   
                 case INTEGER:
 8226  122 
                 case INTEGER_NEGATIVE:
 8227  122 
                 case INTEGER_POSITIVE:
 8228   
                 case IRI_REF:
 8229   
                 case PNAME_LN:
 8230   
                 case PNAME_NS:
 8231   
                 case STRING_LITERAL1:
 8232   
                 case STRING_LITERAL2:
 8233   
                 case STRING_LITERAL_LONG1:
 8234   
                 case STRING_LITERAL_LONG2:
 8235   
                 case TRUE:
 8236   
                 case VAR1:
 8237   
                 case VAR2:
 8238   
                 case 209:
 8239   
                 case 213:
 8240   
                     {
 8241  352 
                     alt59=1;
 8242   
                     }
 8243   
                     break;
 8244   
             }
 8245   
 
 8246  488 
             switch (alt59) {
 8247   
                 case 1 :
 8248   
                     // com\\googlecode\\sparkleg\\Sparql.g:293:7: triplesTemplate
 8249   
                     {
 8250  352 
                     pushFollow(FOLLOW_triplesTemplate_in_quads2268);
 8251  352 
                     triplesTemplate184=triplesTemplate();
 8252  88 
 
 8253  352 
                     state._fsp--;
 8254   
 
 8255  352 
                     stream_triplesTemplate.add(triplesTemplate184.getTree());
 8256   
 
 8257  122 
                     }
 8258   
                     break;
 8259   
 
 8260   
             }
 8261  88 
 
 8262  88 
 
 8263   
             // com\\googlecode\\sparkleg\\Sparql.g:293:24: ( quadsDetails )*
 8264  88 
             loop60:
 8265   
             do {
 8266  712 
                 int alt60=2;
 8267  624 
                 switch ( input.LA(1) ) {
 8268   
                 case GRAPH:
 8269   
                     {
 8270  136 
                     alt60=1;
 8271   
                     }
 8272   
                     break;
 8273   
 
 8274   
                 }
 8275   
 
 8276  624 
                 switch (alt60) {
 8277  156 
                     case 1 :
 8278  156 
                         // com\\googlecode\\sparkleg\\Sparql.g:293:24: quadsDetails
 8279   
                         {
 8280  136 
                         pushFollow(FOLLOW_quadsDetails_in_quads2271);
 8281  170 
                         quadsDetails185=quadsDetails();
 8282   
 
 8283  136 
                         state._fsp--;
 8284   
 
 8285  136 
                         stream_quadsDetails.add(quadsDetails185.getTree());
 8286   
 
 8287  156 
                         }
 8288  136 
                         break;
 8289   
 
 8290   
                     default :
 8291  522 
                         break loop60;
 8292  34 
                 }
 8293  136 
             } while (true);
 8294  34 
 
 8295   
 
 8296  34 
             // AST REWRITE
 8297   
             // elements: triplesTemplate, quadsDetails
 8298   
             // token labels:
 8299  34 
             // rule labels: retval
 8300   
             // token list labels:
 8301   
             // rule list labels:
 8302  122 
             // wildcard labels:
 8303  488 
             retval.tree = root_0;
 8304  522 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8305   
 
 8306  488 
             root_0 = (Object)adaptor.nil();
 8307   
             // 293:38: -> ( triplesTemplate )? ( quadsDetails )*
 8308   
             {
 8309   
                 // com\\googlecode\\sparkleg\\Sparql.g:293:42: ( triplesTemplate )?
 8310  488 
                 if ( stream_triplesTemplate.hasNext() ) {
 8311  352 
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8312   
 
 8313   
                 }
 8314  610 
                 stream_triplesTemplate.reset();
 8315  122 
 
 8316   
                 // com\\googlecode\\sparkleg\\Sparql.g:293:59: ( quadsDetails )*
 8317  746 
                 while ( stream_quadsDetails.hasNext() ) {
 8318  136 
                     adaptor.addChild(root_0, stream_quadsDetails.nextTree());
 8319   
 
 8320   
                 }
 8321  610 
                 stream_quadsDetails.reset();
 8322  88 
 
 8323   
             }
 8324   
 
 8325  122 
 
 8326  488 
             retval.tree = root_0;
 8327   
 
 8328  156 
             }
 8329  34 
 
 8330  488 
             retval.stop = input.LT(-1);
 8331   
 
 8332  122 
 
 8333  488 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8334  488 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8335   
 
 8336   
         }
 8337  122 
         catch (RecognitionException re) {
 8338  0 
             reportError(re);
 8339  0 
             recover(input,re);
 8340  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8341  122 
 
 8342   
         }
 8343   
 
 8344  122 
         finally {
 8345  122 
                 // do for sure before leaving
 8346  488 
         }
 8347  488 
         return retval;
 8348   
     }
 8349   
     // $ANTLR end "quads"
 8350   
 
 8351   
 
 8352  136 
     public static class quadsDetails_return extends ParserRuleReturnScope {
 8353   
         Object tree;
 8354  136 
         public Object getTree() { return tree; }
 8355   
     };
 8356   
 
 8357  122 
 
 8358  122 
     // $ANTLR start "quadsDetails"
 8359   
     // com\\googlecode\\sparkleg\\Sparql.g:296:1: quadsDetails : quadsNotTriples ( '.' )? ( triplesTemplate )? -> quadsNotTriples ( triplesTemplate )? ;
 8360   
     public final SparqlParser.quadsDetails_return quadsDetails() throws RecognitionException {
 8361  136 
         SparqlParser.quadsDetails_return retval = new SparqlParser.quadsDetails_return();
 8362  136 
         retval.start = input.LT(1);
 8363  34 
 
 8364   
 
 8365  136 
         Object root_0 = null;
 8366   
 
 8367  136 
         Token char_literal187=null;
 8368  136 
         SparqlParser.quadsNotTriples_return quadsNotTriples186 =null;
 8369   
 
 8370  136 
         SparqlParser.triplesTemplate_return triplesTemplate188 =null;
 8371   
 
 8372  34 
 
 8373  170 
         Object char_literal187_tree=null;
 8374  136 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8375  136 
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8376  170 
         RewriteRuleSubtreeStream stream_quadsNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule quadsNotTriples");
 8377   
         try {
 8378  34 
             // com\\googlecode\\sparkleg\\Sparql.g:297:5: ( quadsNotTriples ( '.' )? ( triplesTemplate )? -> quadsNotTriples ( triplesTemplate )? )
 8379  34 
             // com\\googlecode\\sparkleg\\Sparql.g:297:7: quadsNotTriples ( '.' )? ( triplesTemplate )?
 8380   
             {
 8381  170 
             pushFollow(FOLLOW_quadsNotTriples_in_quadsDetails2303);
 8382  136 
             quadsNotTriples186=quadsNotTriples();
 8383   
 
 8384  170 
             state._fsp--;
 8385  34 
 
 8386  170 
             stream_quadsNotTriples.add(quadsNotTriples186.getTree());
 8387  34 
 
 8388   
             // com\\googlecode\\sparkleg\\Sparql.g:297:23: ( '.' )?
 8389  136 
             int alt61=2;
 8390  136 
             switch ( input.LA(1) ) {
 8391   
                 case DOT:
 8392  34 
                     {
 8393  34 
                     alt61=1;
 8394   
                     }
 8395  34 
                     break;
 8396   
             }
 8397  34 
 
 8398  136 
             switch (alt61) {
 8399   
                 case 1 :
 8400  34 
                     // com\\googlecode\\sparkleg\\Sparql.g:297:23: '.'
 8401  34 
                     {
 8402  0 
                     char_literal187=(Token)match(input,DOT,FOLLOW_DOT_in_quadsDetails2305);
 8403  0 
                     stream_DOT.add(char_literal187);
 8404   
 
 8405   
 
 8406   
                     }
 8407   
                     break;
 8408   
 
 8409  34 
             }
 8410   
 
 8411   
 
 8412   
             // com\\googlecode\\sparkleg\\Sparql.g:297:28: ( triplesTemplate )?
 8413  136 
             int alt62=2;
 8414  136 
             switch ( input.LA(1) ) {
 8415   
                 case BLANK_NODE_LABEL:
 8416   
                 case DECIMAL:
 8417   
                 case DECIMAL_NEGATIVE:
 8418   
                 case DECIMAL_POSITIVE:
 8419   
                 case DOUBLE:
 8420   
                 case DOUBLE_NEGATIVE:
 8421   
                 case DOUBLE_POSITIVE:
 8422   
                 case FALSE:
 8423   
                 case INTEGER:
 8424  34 
                 case INTEGER_NEGATIVE:
 8425  34 
                 case INTEGER_POSITIVE:
 8426   
                 case IRI_REF:
 8427   
                 case PNAME_LN:
 8428   
                 case PNAME_NS:
 8429   
                 case STRING_LITERAL1:
 8430   
                 case STRING_LITERAL2:
 8431   
                 case STRING_LITERAL_LONG1:
 8432   
                 case STRING_LITERAL_LONG2:
 8433   
                 case TRUE:
 8434   
                 case VAR1:
 8435   
                 case VAR2:
 8436   
                 case 209:
 8437   
                 case 213:
 8438   
                     {
 8439  0 
                     alt62=1;
 8440   
                     }
 8441   
                     break;
 8442   
             }
 8443   
 
 8444  136 
             switch (alt62) {
 8445   
                 case 1 :
 8446   
                     // com\\googlecode\\sparkleg\\Sparql.g:297:28: triplesTemplate
 8447   
                     {
 8448  0 
                     pushFollow(FOLLOW_triplesTemplate_in_quadsDetails2308);
 8449  0 
                     triplesTemplate188=triplesTemplate();
 8450   
 
 8451  0 
                     state._fsp--;
 8452   
 
 8453  0 
                     stream_triplesTemplate.add(triplesTemplate188.getTree());
 8454   
 
 8455  34 
                     }
 8456   
                     break;
 8457   
 
 8458   
             }
 8459   
 
 8460   
 
 8461   
             // AST REWRITE
 8462   
             // elements: quadsNotTriples, triplesTemplate
 8463   
             // token labels:
 8464   
             // rule labels: retval
 8465   
             // token list labels:
 8466   
             // rule list labels:
 8467   
             // wildcard labels:
 8468  136 
             retval.tree = root_0;
 8469  136 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8470   
 
 8471  136 
             root_0 = (Object)adaptor.nil();
 8472   
             // 297:45: -> quadsNotTriples ( triplesTemplate )?
 8473   
             {
 8474  136 
                 adaptor.addChild(root_0, stream_quadsNotTriples.nextTree());
 8475   
 
 8476   
                 // com\\googlecode\\sparkleg\\Sparql.g:297:64: ( triplesTemplate )?
 8477  136 
                 if ( stream_triplesTemplate.hasNext() ) {
 8478  0 
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8479  34 
 
 8480  34 
                 }
 8481  136 
                 stream_triplesTemplate.reset();
 8482  34 
 
 8483   
             }
 8484   
 
 8485  34 
 
 8486  136 
             retval.tree = root_0;
 8487   
 
 8488  34 
             }
 8489   
 
 8490  136 
             retval.stop = input.LT(-1);
 8491   
 
 8492  34 
 
 8493  136 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8494  136 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8495   
 
 8496   
         }
 8497  34 
         catch (RecognitionException re) {
 8498  0 
             reportError(re);
 8499  0 
             recover(input,re);
 8500  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8501  34 
 
 8502   
         }
 8503   
 
 8504  34 
         finally {
 8505  34 
                 // do for sure before leaving
 8506  136 
         }
 8507  136 
         return retval;
 8508   
     }
 8509   
     // $ANTLR end "quadsDetails"
 8510   
 
 8511   
 
 8512  136 
     public static class quadsNotTriples_return extends ParserRuleReturnScope {
 8513   
         Object tree;
 8514  136 
         public Object getTree() { return tree; }
 8515   
     };
 8516   
 
 8517  34 
 
 8518  34 
     // $ANTLR start "quadsNotTriples"
 8519   
     // com\\googlecode\\sparkleg\\Sparql.g:300:1: quadsNotTriples : GRAPH varOrIRIref '{' ( triplesTemplate )? '}' -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) ;
 8520   
     public final SparqlParser.quadsNotTriples_return quadsNotTriples() throws RecognitionException {
 8521  136 
         SparqlParser.quadsNotTriples_return retval = new SparqlParser.quadsNotTriples_return();
 8522  136 
         retval.start = input.LT(1);
 8523  34 
 
 8524   
 
 8525  136 
         Object root_0 = null;
 8526   
 
 8527  136 
         Token GRAPH189=null;
 8528  136 
         Token char_literal191=null;
 8529  136 
         Token char_literal193=null;
 8530  136 
         SparqlParser.varOrIRIref_return varOrIRIref190 =null;
 8531   
 
 8532  170 
         SparqlParser.triplesTemplate_return triplesTemplate192 =null;
 8533  34 
 
 8534   
 
 8535  136 
         Object GRAPH189_tree=null;
 8536  170 
         Object char_literal191_tree=null;
 8537  136 
         Object char_literal193_tree=null;
 8538  170 
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 8539  170 
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 8540  170 
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 8541  170 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 8542  136 
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8543  34 
         try {
 8544   
             // com\\googlecode\\sparkleg\\Sparql.g:301:5: ( GRAPH varOrIRIref '{' ( triplesTemplate )? '}' -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) )
 8545   
             // com\\googlecode\\sparkleg\\Sparql.g:301:7: GRAPH varOrIRIref '{' ( triplesTemplate )? '}'
 8546  34 
             {
 8547  170 
             GRAPH189=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_quadsNotTriples2338);
 8548  170 
             stream_GRAPH.add(GRAPH189);
 8549  34 
 
 8550  34 
 
 8551  170 
             pushFollow(FOLLOW_varOrIRIref_in_quadsNotTriples2340);
 8552  170 
             varOrIRIref190=varOrIRIref();
 8553  34 
 
 8554  136 
             state._fsp--;
 8555   
 
 8556  136 
             stream_varOrIRIref.add(varOrIRIref190.getTree());
 8557   
 
 8558  170 
             char_literal191=(Token)match(input,216,FOLLOW_216_in_quadsNotTriples2342);
 8559  170 
             stream_216.add(char_literal191);
 8560   
 
 8561   
 
 8562  34 
             // com\\googlecode\\sparkleg\\Sparql.g:301:29: ( triplesTemplate )?
 8563  170 
             int alt63=2;
 8564  136 
             switch ( input.LA(1) ) {
 8565  34 
                 case BLANK_NODE_LABEL:
 8566   
                 case DECIMAL:
 8567  34 
                 case DECIMAL_NEGATIVE:
 8568   
                 case DECIMAL_POSITIVE:
 8569  34 
                 case DOUBLE:
 8570  34 
                 case DOUBLE_NEGATIVE:
 8571   
                 case DOUBLE_POSITIVE:
 8572   
                 case FALSE:
 8573   
                 case INTEGER:
 8574  34 
                 case INTEGER_NEGATIVE:
 8575  34 
                 case INTEGER_POSITIVE:
 8576   
                 case IRI_REF:
 8577   
                 case PNAME_LN:
 8578   
                 case PNAME_NS:
 8579   
                 case STRING_LITERAL1:
 8580   
                 case STRING_LITERAL2:
 8581   
                 case STRING_LITERAL_LONG1:
 8582   
                 case STRING_LITERAL_LONG2:
 8583   
                 case TRUE:
 8584   
                 case VAR1:
 8585   
                 case VAR2:
 8586   
                 case 209:
 8587   
                 case 213:
 8588   
                     {
 8589  136 
                     alt63=1;
 8590   
                     }
 8591   
                     break;
 8592   
             }
 8593   
 
 8594  136 
             switch (alt63) {
 8595   
                 case 1 :
 8596   
                     // com\\googlecode\\sparkleg\\Sparql.g:301:29: triplesTemplate
 8597   
                     {
 8598  136 
                     pushFollow(FOLLOW_triplesTemplate_in_quadsNotTriples2344);
 8599  136 
                     triplesTemplate192=triplesTemplate();
 8600  34 
 
 8601  136 
                     state._fsp--;
 8602   
 
 8603  136 
                     stream_triplesTemplate.add(triplesTemplate192.getTree());
 8604   
 
 8605  34 
                     }
 8606   
                     break;
 8607   
 
 8608   
             }
 8609  34 
 
 8610  34 
 
 8611  136 
             char_literal193=(Token)match(input,218,FOLLOW_218_in_quadsNotTriples2347);
 8612  170 
             stream_218.add(char_literal193);
 8613   
 
 8614  34 
 
 8615   
             // AST REWRITE
 8616   
             // elements: GRAPH, varOrIRIref, triplesTemplate
 8617   
             // token labels:
 8618   
             // rule labels: retval
 8619   
             // token list labels:
 8620   
             // rule list labels:
 8621   
             // wildcard labels:
 8622  170 
             retval.tree = root_0;
 8623  170 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8624   
 
 8625  136 
             root_0 = (Object)adaptor.nil();
 8626   
             // 301:50: -> ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8627   
             {
 8628   
                 // com\\googlecode\\sparkleg\\Sparql.g:301:53: ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8629   
                 {
 8630  136 
                 Object root_1 = (Object)adaptor.nil();
 8631  136 
                 root_1 = (Object)adaptor.becomeRoot(
 8632   
                 stream_GRAPH.nextNode()
 8633  34 
                 , root_1);
 8634  34 
 
 8635  136 
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 8636  34 
 
 8637   
                 // com\\googlecode\\sparkleg\\Sparql.g:301:73: ( triplesTemplate )?
 8638  136 
                 if ( stream_triplesTemplate.hasNext() ) {
 8639  136 
                     adaptor.addChild(root_1, stream_triplesTemplate.nextTree());
 8640   
 
 8641  34 
                 }
 8642  170 
                 stream_triplesTemplate.reset();
 8643   
 
 8644  136 
                 adaptor.addChild(root_0, root_1);
 8645   
                 }
 8646  34 
 
 8647   
             }
 8648   
 
 8649  34 
 
 8650  170 
             retval.tree = root_0;
 8651   
 
 8652   
             }
 8653  34 
 
 8654  136 
             retval.stop = input.LT(-1);
 8655  34 
 
 8656   
 
 8657  136 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8658  136 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8659   
 
 8660   
         }
 8661  34 
         catch (RecognitionException re) {
 8662  0 
             reportError(re);
 8663  0 
             recover(input,re);
 8664  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8665  34 
 
 8666   
         }
 8667   
 
 8668  34 
         finally {
 8669  34 
                 // do for sure before leaving
 8670  136 
         }
 8671  136 
         return retval;
 8672   
     }
 8673   
     // $ANTLR end "quadsNotTriples"
 8674   
 
 8675   
 
 8676  538 
     public static class triplesTemplate_return extends ParserRuleReturnScope {
 8677   
         Object tree;
 8678  538 
         public Object getTree() { return tree; }
 8679   
     };
 8680   
 
 8681  34 
 
 8682  34 
     // $ANTLR start "triplesTemplate"
 8683   
     // com\\googlecode\\sparkleg\\Sparql.g:304:1: triplesTemplate : triplesSameSubject ( '.' triplesSameSubject )* ( '.' )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) ;
 8684   
     public final SparqlParser.triplesTemplate_return triplesTemplate() throws RecognitionException {
 8685  538 
         SparqlParser.triplesTemplate_return retval = new SparqlParser.triplesTemplate_return();
 8686  538 
         retval.start = input.LT(1);
 8687  136 
 
 8688   
 
 8689  538 
         Object root_0 = null;
 8690   
 
 8691  538 
         Token char_literal195=null;
 8692  538 
         Token char_literal197=null;
 8693  538 
         SparqlParser.triplesSameSubject_return triplesSameSubject194 =null;
 8694   
 
 8695  538 
         SparqlParser.triplesSameSubject_return triplesSameSubject196 =null;
 8696  136 
 
 8697  136 
 
 8698  538 
         Object char_literal195_tree=null;
 8699  538 
         Object char_literal197_tree=null;
 8700  674 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8701  538 
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 8702  136 
         try {
 8703  136 
             // com\\googlecode\\sparkleg\\Sparql.g:305:5: ( triplesSameSubject ( '.' triplesSameSubject )* ( '.' )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) )
 8704  136 
             // com\\googlecode\\sparkleg\\Sparql.g:305:7: triplesSameSubject ( '.' triplesSameSubject )* ( '.' )?
 8705   
             {
 8706  674 
             pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2379);
 8707  538 
             triplesSameSubject194=triplesSameSubject();
 8708   
 
 8709  674 
             state._fsp--;
 8710  136 
 
 8711  674 
             stream_triplesSameSubject.add(triplesSameSubject194.getTree());
 8712  136 
 
 8713   
             // com\\googlecode\\sparkleg\\Sparql.g:305:26: ( '.' triplesSameSubject )*
 8714   
             loop64:
 8715   
             do {
 8716  562 
                 int alt64=2;
 8717  698 
                 switch ( input.LA(1) ) {
 8718  136 
                 case DOT:
 8719   
                     {
 8720  556 
                     switch ( input.LA(2) ) {
 8721   
                     case BLANK_NODE_LABEL:
 8722  136 
                     case DECIMAL:
 8723   
                     case DECIMAL_NEGATIVE:
 8724   
                     case DECIMAL_POSITIVE:
 8725   
                     case DOUBLE:
 8726   
                     case DOUBLE_NEGATIVE:
 8727  142 
                     case DOUBLE_POSITIVE:
 8728  142 
                     case FALSE:
 8729   
                     case INTEGER:
 8730   
                     case INTEGER_NEGATIVE:
 8731  84 
                     case INTEGER_POSITIVE:
 8732   
                     case IRI_REF:
 8733   
                     case PNAME_LN:
 8734   
                     case PNAME_NS:
 8735   
                     case STRING_LITERAL1:
 8736   
                     case STRING_LITERAL2:
 8737   
                     case STRING_LITERAL_LONG1:
 8738   
                     case STRING_LITERAL_LONG2:
 8739   
                     case TRUE:
 8740   
                     case VAR1:
 8741   
                     case VAR2:
 8742   
                     case 209:
 8743   
                     case 213:
 8744   
                         {
 8745  24 
                         alt64=1;
 8746   
                         }
 8747   
                         break;
 8748   
 
 8749   
                     }
 8750   
 
 8751   
                     }
 8752   
                     break;
 8753   
 
 8754   
                 }
 8755   
 
 8756  568 
                 switch (alt64) {
 8757   
                     case 1 :
 8758   
                         // com\\googlecode\\sparkleg\\Sparql.g:305:27: '.' triplesSameSubject
 8759   
                         {
 8760  24 
                         char_literal195=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2382);
 8761  24 
                         stream_DOT.add(char_literal195);
 8762   
 
 8763   
 
 8764  24 
                         pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2384);
 8765  24 
                         triplesSameSubject196=triplesSameSubject();
 8766   
 
 8767  166 
                         state._fsp--;
 8768   
 
 8769  24 
                         stream_triplesSameSubject.add(triplesSameSubject196.getTree());
 8770   
 
 8771  6 
                         }
 8772  30 
                         break;
 8773   
 
 8774   
                     default :
 8775  544 
                         break loop64;
 8776  6 
                 }
 8777  24 
             } while (true);
 8778  6 
 
 8779   
 
 8780  6 
             // com\\googlecode\\sparkleg\\Sparql.g:305:52: ( '.' )?
 8781  538 
             int alt65=2;
 8782  538 
             switch ( input.LA(1) ) {
 8783  6 
                 case DOT:
 8784   
                     {
 8785  396 
                     alt65=1;
 8786  136 
                     }
 8787   
                     break;
 8788  6 
             }
 8789   
 
 8790  538 
             switch (alt65) {
 8791   
                 case 1 :
 8792  136 
                     // com\\googlecode\\sparkleg\\Sparql.g:305:52: '.'
 8793  136 
                     {
 8794  396 
                     char_literal197=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2388);
 8795  396 
                     stream_DOT.add(char_literal197);
 8796  78 
 
 8797   
 
 8798   
                     }
 8799   
                     break;
 8800   
 
 8801  136 
             }
 8802   
 
 8803   
 
 8804   
             // AST REWRITE
 8805  78 
             // elements: triplesSameSubject
 8806  78 
             // token labels:
 8807   
             // rule labels: retval
 8808   
             // token list labels:
 8809   
             // rule list labels:
 8810   
             // wildcard labels:
 8811  538 
             retval.tree = root_0;
 8812  538 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8813   
 
 8814  538 
             root_0 = (Object)adaptor.nil();
 8815   
             // 305:57: -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8816   
             {
 8817   
                 // com\\googlecode\\sparkleg\\Sparql.g:305:60: ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8818   
                 {
 8819  538 
                 Object root_1 = (Object)adaptor.nil();
 8820  538 
                 root_1 = (Object)adaptor.becomeRoot(
 8821   
                 (Object)adaptor.create(TRIPLES_TEMPLATE, "TRIPLES_TEMPLATE")
 8822  136 
                 , root_1);
 8823  136 
 
 8824   
                 // com\\googlecode\\sparkleg\\Sparql.g:305:79: ( triplesSameSubject )*
 8825  1236 
                 while ( stream_triplesSameSubject.hasNext() ) {
 8826  562 
                     adaptor.addChild(root_1, stream_triplesSameSubject.nextTree());
 8827   
 
 8828   
                 }
 8829  538 
                 stream_triplesSameSubject.reset();
 8830  136 
 
 8831  674 
                 adaptor.addChild(root_0, root_1);
 8832   
                 }
 8833   
 
 8834   
             }
 8835   
 
 8836  278 
 
 8837  680 
             retval.tree = root_0;
 8838   
 
 8839   
             }
 8840  136 
 
 8841  538 
             retval.stop = input.LT(-1);
 8842  136 
 
 8843   
 
 8844  538 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8845  538 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8846   
 
 8847   
         }
 8848  136 
         catch (RecognitionException re) {
 8849  0 
             reportError(re);
 8850  0 
             recover(input,re);
 8851  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8852  136 
 
 8853   
         }
 8854   
 
 8855  136 
         finally {
 8856  136 
                 // do for sure before leaving
 8857  538 
         }
 8858  538 
         return retval;
 8859   
     }
 8860   
     // $ANTLR end "triplesTemplate"
 8861   
 
 8862   
 
 8863  10558 
     public static class groupGraphPattern_return extends ParserRuleReturnScope {
 8864   
         Object tree;
 8865  10558 
         public Object getTree() { return tree; }
 8866   
     };
 8867   
 
 8868  136 
 
 8869  136 
     // $ANTLR start "groupGraphPattern"
 8870   
     // com\\googlecode\\sparkleg\\Sparql.g:308:1: groupGraphPattern : ( '{' subSelect '}' -> ^( GROUP_GRAPH_PATTERN subSelect ) | '{' groupGraphPatternSub '}' -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | '{' '}' -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) );
 8871   
     public final SparqlParser.groupGraphPattern_return groupGraphPattern() throws RecognitionException {
 8872  10558 
         SparqlParser.groupGraphPattern_return retval = new SparqlParser.groupGraphPattern_return();
 8873  10558 
         retval.start = input.LT(1);
 8874  2692 
 
 8875   
 
 8876  2692 
         Object root_0 = null;
 8877   
 
 8878  10558 
         Token char_literal198=null;
 8879  10558 
         Token char_literal200=null;
 8880  10558 
         Token char_literal201=null;
 8881  10558 
         Token char_literal203=null;
 8882  10558 
         Token char_literal204=null;
 8883  13250 
         Token char_literal205=null;
 8884  13250 
         SparqlParser.subSelect_return subSelect199 =null;
 8885   
 
 8886  10558 
         SparqlParser.groupGraphPatternSub_return groupGraphPatternSub202 =null;
 8887  2692 
 
 8888   
 
 8889  13250 
         Object char_literal198_tree=null;
 8890  13250 
         Object char_literal200_tree=null;
 8891  13250 
         Object char_literal201_tree=null;
 8892  13250 
         Object char_literal203_tree=null;
 8893  13250 
         Object char_literal204_tree=null;
 8894  13250 
         Object char_literal205_tree=null;
 8895  13250 
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 8896  10558 
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 8897  13250 
         RewriteRuleSubtreeStream stream_groupGraphPatternSub=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSub");
 8898  10558 
         RewriteRuleSubtreeStream stream_subSelect=new RewriteRuleSubtreeStream(adaptor,"rule subSelect");
 8899   
         try {
 8900  2692 
             // com\\googlecode\\sparkleg\\Sparql.g:309:5: ( '{' subSelect '}' -> ^( GROUP_GRAPH_PATTERN subSelect ) | '{' groupGraphPatternSub '}' -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | '{' '}' -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) )
 8901  13250 
             int alt66=3;
 8902  13250 
             switch ( input.LA(1) ) {
 8903  2692 
             case 216:
 8904  2692 
                 {
 8905  13238 
                 switch ( input.LA(2) ) {
 8906  2692 
                 case 218:
 8907  2692 
                     {
 8908  2868 
                     alt66=3;
 8909  2692 
                     }
 8910  176 
                     break;
 8911   
                 case SELECT:
 8912  2692 
                     {
 8913  2876 
                     alt66=1;
 8914   
                     }
 8915  184 
                     break;
 8916  2680 
                 case BIND:
 8917   
                 case BLANK_NODE_LABEL:
 8918   
                 case DECIMAL:
 8919  44 
                 case DECIMAL_NEGATIVE:
 8920   
                 case DECIMAL_POSITIVE:
 8921  44 
                 case DOUBLE:
 8922   
                 case DOUBLE_NEGATIVE:
 8923   
                 case DOUBLE_POSITIVE:
 8924  46 
                 case FALSE:
 8925   
                 case FILTER:
 8926  46 
                 case GRAPH:
 8927   
                 case INTEGER:
 8928   
                 case INTEGER_NEGATIVE:
 8929   
                 case INTEGER_POSITIVE:
 8930   
                 case IRI_REF:
 8931   
                 case MINUS_KEYWORD:
 8932   
                 case OPTIONAL:
 8933   
                 case PNAME_LN:
 8934   
                 case PNAME_NS:
 8935   
                 case SERVICE:
 8936   
                 case STRING_LITERAL1:
 8937   
                 case STRING_LITERAL2:
 8938   
                 case STRING_LITERAL_LONG1:
 8939   
                 case STRING_LITERAL_LONG2:
 8940   
                 case TRUE:
 8941   
                 case VAR1:
 8942   
                 case VAR2:
 8943   
                 case 209:
 8944   
                 case 213:
 8945   
                 case 216:
 8946   
                     {
 8947  10176 
                     alt66=2;
 8948   
                     }
 8949  10176 
                     break;
 8950   
                 default:
 8951  10 
                     NoViableAltException nvae =
 8952   
                         new NoViableAltException("", 66, 1, input);
 8953   
 
 8954  10 
                     throw nvae;
 8955   
 
 8956   
                 }
 8957   
 
 8958  2580 
                 }
 8959  10536 
                 break;
 8960  2580 
             default:
 8961  12 
                 NoViableAltException nvae =
 8962  10 
                     new NoViableAltException("", 66, 0, input);
 8963   
 
 8964  12 
                 throw nvae;
 8965  10 
 
 8966   
             }
 8967   
 
 8968  10536 
             switch (alt66) {
 8969   
                 case 1 :
 8970  2670 
                     // com\\googlecode\\sparkleg\\Sparql.g:309:7: '{' subSelect '}'
 8971   
                     {
 8972  196 
                     char_literal198=(Token)match(input,216,FOLLOW_216_in_groupGraphPattern2420);
 8973  184 
                     stream_216.add(char_literal198);
 8974   
 
 8975  12 
 
 8976  184 
                     pushFollow(FOLLOW_subSelect_in_groupGraphPattern2422);
 8977  184 
                     subSelect199=subSelect();
 8978   
 
 8979  2854 
                     state._fsp--;
 8980   
 
 8981  184 
                     stream_subSelect.add(subSelect199.getTree());
 8982   
 
 8983  230 
                     char_literal200=(Token)match(input,218,FOLLOW_218_in_groupGraphPattern2424);
 8984  230 
                     stream_218.add(char_literal200);
 8985   
 
 8986   
 
 8987  46 
                     // AST REWRITE
 8988  46 
                     // elements: subSelect
 8989   
                     // token labels:
 8990  46 
                     // rule labels: retval
 8991   
                     // token list labels:
 8992  46 
                     // rule list labels:
 8993   
                     // wildcard labels:
 8994  230 
                     retval.tree = root_0;
 8995  230 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8996   
 
 8997  184 
                     root_0 = (Object)adaptor.nil();
 8998   
                     // 309:25: -> ^( GROUP_GRAPH_PATTERN subSelect )
 8999   
                     {
 9000   
                         // com\\googlecode\\sparkleg\\Sparql.g:309:28: ^( GROUP_GRAPH_PATTERN subSelect )
 9001   
                         {
 9002  184 
                         Object root_1 = (Object)adaptor.nil();
 9003  184 
                         root_1 = (Object)adaptor.becomeRoot(
 9004   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9005  46 
                         , root_1);
 9006  46 
 
 9007  184 
                         adaptor.addChild(root_1, stream_subSelect.nextTree());
 9008  46 
 
 9009  184 
                         adaptor.addChild(root_0, root_1);
 9010   
                         }
 9011   
 
 9012   
                     }
 9013  46 
 
 9014  46 
 
 9015  184 
                     retval.tree = root_0;
 9016   
 
 9017   
                     }
 9018  230 
                     break;
 9019   
                 case 2 :
 9020  46 
                     // com\\googlecode\\sparkleg\\Sparql.g:310:7: '{' groupGraphPatternSub '}'
 9021   
                     {
 9022  10176 
                     char_literal201=(Token)match(input,216,FOLLOW_216_in_groupGraphPattern2440);
 9023  10176 
                     stream_216.add(char_literal201);
 9024   
 
 9025   
 
 9026  10222 
                     pushFollow(FOLLOW_groupGraphPatternSub_in_groupGraphPattern2442);
 9027  10176 
                     groupGraphPatternSub202=groupGraphPatternSub();
 9028   
 
 9029  10222 
                     state._fsp--;
 9030   
 
 9031  10176 
                     stream_groupGraphPatternSub.add(groupGraphPatternSub202.getTree());
 9032   
 
 9033  12756 
                     char_literal203=(Token)match(input,218,FOLLOW_218_in_groupGraphPattern2444);
 9034  12738 
                     stream_218.add(char_literal203);
 9035   
 
 9036   
 
 9037  2580 
                     // AST REWRITE
 9038  2580 
                     // elements: groupGraphPatternSub
 9039   
                     // token labels:
 9040  2580 
                     // rule labels: retval
 9041   
                     // token list labels:
 9042  2580 
                     // rule list labels:
 9043   
                     // wildcard labels:
 9044  12738 
                     retval.tree = root_0;
 9045  12720 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9046   
 
 9047  10158 
                     root_0 = (Object)adaptor.nil();
 9048   
                     // 310:36: -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 9049   
                     {
 9050   
                         // com\\googlecode\\sparkleg\\Sparql.g:310:39: ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 9051   
                         {
 9052  10158 
                         Object root_1 = (Object)adaptor.nil();
 9053  10158 
                         root_1 = (Object)adaptor.becomeRoot(
 9054   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9055  2562 
                         , root_1);
 9056  2562 
 
 9057  10158 
                         adaptor.addChild(root_1, stream_groupGraphPatternSub.nextTree());
 9058  2562 
 
 9059  10158 
                         adaptor.addChild(root_0, root_1);
 9060   
                         }
 9061   
 
 9062   
                     }
 9063  2562 
 
 9064  2562 
 
 9065  10158 
                     retval.tree = root_0;
 9066   
 
 9067   
                     }
 9068  12720 
                     break;
 9069   
                 case 3 :
 9070  2562 
                     // com\\googlecode\\sparkleg\\Sparql.g:311:7: '{' '}'
 9071   
                     {
 9072  176 
                     char_literal204=(Token)match(input,216,FOLLOW_216_in_groupGraphPattern2460);
 9073  176 
                     stream_216.add(char_literal204);
 9074   
 
 9075   
 
 9076  2738 
                     char_literal205=(Token)match(input,218,FOLLOW_218_in_groupGraphPattern2462);
 9077  176 
                     stream_218.add(char_literal205);
 9078   
 
 9079  2562 
 
 9080   
                     // AST REWRITE
 9081   
                     // elements:
 9082   
                     // token labels:
 9083  44 
                     // rule labels: retval
 9084  44 
                     // token list labels:
 9085   
                     // rule list labels:
 9086   
                     // wildcard labels:
 9087  220 
                     retval.tree = root_0;
 9088  220 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9089   
 
 9090  176 
                     root_0 = (Object)adaptor.nil();
 9091   
                     // 311:15: -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 9092   
                     {
 9093   
                         // com\\googlecode\\sparkleg\\Sparql.g:311:18: ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 9094   
                         {
 9095  176 
                         Object root_1 = (Object)adaptor.nil();
 9096  176 
                         root_1 = (Object)adaptor.becomeRoot(
 9097   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9098  44 
                         , root_1);
 9099  44 
 
 9100  176 
                         adaptor.addChild(root_1,
 9101  44 
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9102   
                         );
 9103   
 
 9104  176 
                         adaptor.addChild(root_0, root_1);
 9105   
                         }
 9106  44 
 
 9107  44 
                     }
 9108   
 
 9109   
 
 9110  176 
                     retval.tree = root_0;
 9111  44 
 
 9112   
                     }
 9113   
                     break;
 9114   
 
 9115  44 
             }
 9116  10518 
             retval.stop = input.LT(-1);
 9117   
 
 9118   
 
 9119  10518 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9120  10518 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9121  44 
 
 9122   
         }
 9123  40 
         catch (RecognitionException re) {
 9124  40 
             reportError(re);
 9125  40 
             recover(input,re);
 9126  40 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9127  2652 
 
 9128   
         }
 9129   
 
 9130  2652 
         finally {
 9131  2652 
                 // do for sure before leaving
 9132  10558 
         }
 9133  10558 
         return retval;
 9134  40 
     }
 9135  40 
     // $ANTLR end "groupGraphPattern"
 9136  40 
 
 9137  40 
 
 9138  10176 
     public static class groupGraphPatternSub_return extends ParserRuleReturnScope {
 9139   
         Object tree;
 9140  10176 
         public Object getTree() { return tree; }
 9141   
     };
 9142   
 
 9143  2692 
 
 9144  2692 
     // $ANTLR start "groupGraphPatternSub"
 9145   
     // com\\googlecode\\sparkleg\\Sparql.g:314:1: groupGraphPatternSub : ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ );
 9146   
     public final SparqlParser.groupGraphPatternSub_return groupGraphPatternSub() throws RecognitionException {
 9147  10176 
         SparqlParser.groupGraphPatternSub_return retval = new SparqlParser.groupGraphPatternSub_return();
 9148  10176 
         retval.start = input.LT(1);
 9149  2580 
 
 9150   
 
 9151  10176 
         Object root_0 = null;
 9152   
 
 9153  10176 
         SparqlParser.triplesBlock_return triplesBlock206 =null;
 9154   
 
 9155  10176 
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail207 =null;
 9156   
 
 9157  10176 
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail208 =null;
 9158  2580 
 
 9159  2580 
 
 9160  10176 
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9161  10176 
         RewriteRuleSubtreeStream stream_groupGraphPatternSubDetail=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSubDetail");
 9162  2580 
         try {
 9163   
             // com\\googlecode\\sparkleg\\Sparql.g:315:5: ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ )
 9164  12756 
             int alt69=2;
 9165  10176 
             switch ( input.LA(1) ) {
 9166  2580 
             case BLANK_NODE_LABEL:
 9167   
             case DECIMAL:
 9168  2580 
             case DECIMAL_NEGATIVE:
 9169   
             case DECIMAL_POSITIVE:
 9170   
             case DOUBLE:
 9171  2580 
             case DOUBLE_NEGATIVE:
 9172  2580 
             case DOUBLE_POSITIVE:
 9173   
             case FALSE:
 9174   
             case INTEGER:
 9175  2580 
             case INTEGER_NEGATIVE:
 9176  2580 
             case INTEGER_POSITIVE:
 9177   
             case IRI_REF:
 9178   
             case PNAME_LN:
 9179   
             case PNAME_NS:
 9180   
             case STRING_LITERAL1:
 9181   
             case STRING_LITERAL2:
 9182   
             case STRING_LITERAL_LONG1:
 9183   
             case STRING_LITERAL_LONG2:
 9184   
             case TRUE:
 9185   
             case VAR1:
 9186   
             case VAR2:
 9187   
             case 209:
 9188   
             case 213:
 9189   
                 {
 9190  9056 
                 alt69=1;
 9191   
                 }
 9192  9056 
                 break;
 9193   
             case BIND:
 9194   
             case FILTER:
 9195   
             case GRAPH:
 9196   
             case MINUS_KEYWORD:
 9197   
             case OPTIONAL:
 9198   
             case SERVICE:
 9199   
             case 216:
 9200   
                 {
 9201  3414 
                 alt69=2;
 9202   
                 }
 9203  3414 
                 break;
 9204   
             default:
 9205  0 
                 NoViableAltException nvae =
 9206   
                     new NoViableAltException("", 69, 0, input);
 9207   
 
 9208  0 
                 throw nvae;
 9209   
 
 9210   
             }
 9211   
 
 9212  10462 
             switch (alt69) {
 9213   
                 case 1 :
 9214  286 
                     // com\\googlecode\\sparkleg\\Sparql.g:315:7: triplesBlock ( groupGraphPatternSubDetail )*
 9215   
                     {
 9216  9056 
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSub2491);
 9217  9056 
                     triplesBlock206=triplesBlock();
 9218   
 
 9219  9056 
                     state._fsp--;
 9220   
 
 9221  9056 
                     stream_triplesBlock.add(triplesBlock206.getTree());
 9222   
 
 9223  2580 
                     // com\\googlecode\\sparkleg\\Sparql.g:315:20: ( groupGraphPatternSubDetail )*
 9224   
                     loop67:
 9225   
                     do {
 9226  12552 
                         int alt67=2;
 9227  14846 
                         switch ( input.LA(1) ) {
 9228  2294 
                         case BIND:
 9229   
                         case FILTER:
 9230  2294 
                         case GRAPH:
 9231   
                         case MINUS_KEYWORD:
 9232  2294 
                         case OPTIONAL:
 9233   
                         case SERVICE:
 9234   
                         case 216:
 9235   
                             {
 9236  3496 
                             alt67=1;
 9237  3174 
                             }
 9238  3174 
                             break;
 9239   
 
 9240   
                         }
 9241   
 
 9242  12552 
                         switch (alt67) {
 9243   
                             case 1 :
 9244   
                                 // com\\googlecode\\sparkleg\\Sparql.g:315:20: groupGraphPatternSubDetail
 9245   
                                 {
 9246  3496 
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2493);
 9247  4376 
                                 groupGraphPatternSubDetail207=groupGraphPatternSubDetail();
 9248   
 
 9249  3496 
                                 state._fsp--;
 9250   
 
 9251  3496 
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail207.getTree());
 9252   
 
 9253  3174 
                                 }
 9254  3496 
                                 break;
 9255   
 
 9256   
                             default :
 9257  9936 
                                 break loop67;
 9258  880 
                         }
 9259  3496 
                     } while (true);
 9260  880 
 
 9261   
 
 9262  880 
                     // AST REWRITE
 9263   
                     // elements: triplesBlock, groupGraphPatternSubDetail
 9264   
                     // token labels:
 9265  880 
                     // rule labels: retval
 9266   
                     // token list labels:
 9267   
                     // rule list labels:
 9268  2294 
                     // wildcard labels:
 9269  9056 
                     retval.tree = root_0;
 9270  9936 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9271   
 
 9272  9056 
                     root_0 = (Object)adaptor.nil();
 9273   
                     // 315:48: -> triplesBlock ( groupGraphPatternSubDetail )*
 9274   
                     {
 9275  9056 
                         adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9276   
 
 9277   
                         // com\\googlecode\\sparkleg\\Sparql.g:315:64: ( groupGraphPatternSubDetail )*
 9278  12552 
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9279  3496 
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9280  2294 
 
 9281  2294 
                         }
 9282  9056 
                         stream_groupGraphPatternSubDetail.reset();
 9283  2294 
 
 9284   
                     }
 9285   
 
 9286  2294 
 
 9287  9056 
                     retval.tree = root_0;
 9288   
 
 9289  3174 
                     }
 9290  9936 
                     break;
 9291   
                 case 2 :
 9292   
                     // com\\googlecode\\sparkleg\\Sparql.g:316:7: ( groupGraphPatternSubDetail )+
 9293  2294 
                     {
 9294   
                     // com\\googlecode\\sparkleg\\Sparql.g:316:7: ( groupGraphPatternSubDetail )+
 9295  1120 
                     int cnt68=0;
 9296   
                     loop68:
 9297   
                     do {
 9298  4800 
                         int alt68=2;
 9299  2506 
                         switch ( input.LA(1) ) {
 9300   
                         case BIND:
 9301  2294 
                         case FILTER:
 9302   
                         case GRAPH:
 9303   
                         case MINUS_KEYWORD:
 9304   
                         case OPTIONAL:
 9305   
                         case SERVICE:
 9306  286 
                         case 216:
 9307   
                             {
 9308  1386 
                             alt68=1;
 9309  646 
                             }
 9310  646 
                             break;
 9311   
 
 9312   
                         }
 9313   
 
 9314  2506 
                         switch (alt68) {
 9315   
                             case 1 :
 9316   
                                 // com\\googlecode\\sparkleg\\Sparql.g:316:7: groupGraphPatternSubDetail
 9317   
                                 {
 9318  1386 
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2509);
 9319  1746 
                                 groupGraphPatternSubDetail208=groupGraphPatternSubDetail();
 9320   
 
 9321  1386 
                                 state._fsp--;
 9322   
 
 9323  1386 
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail208.getTree());
 9324   
 
 9325  646 
                                 }
 9326  1386 
                                 break;
 9327   
 
 9328   
                             default :
 9329  1480 
                                 if ( cnt68 >= 1 ) break loop68;
 9330  360 
                                 EarlyExitException eee =
 9331   
                                     new EarlyExitException(68, input);
 9332  360 
                                 throw eee;
 9333   
                         }
 9334  1746 
                         cnt68++;
 9335  1386 
                     } while (true);
 9336   
 
 9337  360 
 
 9338   
                     // AST REWRITE
 9339   
                     // elements: groupGraphPatternSubDetail
 9340  286 
                     // token labels:
 9341   
                     // rule labels: retval
 9342   
                     // token list labels:
 9343   
                     // rule list labels:
 9344   
                     // wildcard labels:
 9345  1480 
                     retval.tree = root_0;
 9346  1480 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9347   
 
 9348  1120 
                     root_0 = (Object)adaptor.nil();
 9349   
                     // 316:35: -> ( groupGraphPatternSubDetail )+
 9350   
                     {
 9351  1120 
                         if ( !(stream_groupGraphPatternSubDetail.hasNext()) ) {
 9352  0 
                             throw new RewriteEarlyExitException();
 9353   
                         }
 9354  2506 
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9355  1386 
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9356  286 
 
 9357  286 
                         }
 9358  1120 
                         stream_groupGraphPatternSubDetail.reset();
 9359  286 
 
 9360   
                     }
 9361   
 
 9362  286 
 
 9363  1120 
                     retval.tree = root_0;
 9364   
 
 9365  646 
                     }
 9366  360 
                     break;
 9367   
 
 9368   
             }
 9369  10462 
             retval.stop = input.LT(-1);
 9370   
 
 9371   
 
 9372  10176 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9373  10176 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9374  286 
 
 9375   
         }
 9376  0 
         catch (RecognitionException re) {
 9377  0 
             reportError(re);
 9378  0 
             recover(input,re);
 9379  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9380  2580 
 
 9381   
         }
 9382   
 
 9383  2580 
         finally {
 9384  2580 
                 // do for sure before leaving
 9385  10176 
         }
 9386  10176 
         return retval;
 9387   
     }
 9388   
     // $ANTLR end "groupGraphPatternSub"
 9389   
 
 9390   
 
 9391  4882 
     public static class groupGraphPatternSubDetail_return extends ParserRuleReturnScope {
 9392   
         Object tree;
 9393  4882 
         public Object getTree() { return tree; }
 9394   
     };
 9395   
 
 9396  2580 
 
 9397  2580 
     // $ANTLR start "groupGraphPatternSubDetail"
 9398   
     // com\\googlecode\\sparkleg\\Sparql.g:319:1: groupGraphPatternSubDetail : graphPatternNotTriples ( '.' )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? ;
 9399   
     public final SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail() throws RecognitionException {
 9400  4882 
         SparqlParser.groupGraphPatternSubDetail_return retval = new SparqlParser.groupGraphPatternSubDetail_return();
 9401  4882 
         retval.start = input.LT(1);
 9402  1240 
 
 9403   
 
 9404  1240 
         Object root_0 = null;
 9405   
 
 9406  4882 
         Token char_literal210=null;
 9407  4882 
         SparqlParser.graphPatternNotTriples_return graphPatternNotTriples209 =null;
 9408   
 
 9409  4882 
         SparqlParser.triplesBlock_return triplesBlock211 =null;
 9410   
 
 9411  1240 
 
 9412  6122 
         Object char_literal210_tree=null;
 9413  4882 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9414  4882 
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9415  6122 
         RewriteRuleSubtreeStream stream_graphPatternNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule graphPatternNotTriples");
 9416   
         try {
 9417  1240 
             // com\\googlecode\\sparkleg\\Sparql.g:320:5: ( graphPatternNotTriples ( '.' )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? )
 9418  1240 
             // com\\googlecode\\sparkleg\\Sparql.g:320:7: graphPatternNotTriples ( '.' )? ( triplesBlock )?
 9419   
             {
 9420  6122 
             pushFollow(FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2532);
 9421  4882 
             graphPatternNotTriples209=graphPatternNotTriples();
 9422   
 
 9423  6122 
             state._fsp--;
 9424  1240 
 
 9425  6122 
             stream_graphPatternNotTriples.add(graphPatternNotTriples209.getTree());
 9426  1240 
 
 9427   
             // com\\googlecode\\sparkleg\\Sparql.g:320:30: ( '.' )?
 9428  4882 
             int alt70=2;
 9429  4882 
             switch ( input.LA(1) ) {
 9430   
                 case DOT:
 9431  1240 
                     {
 9432  1730 
                     alt70=1;
 9433   
                     }
 9434  1240 
                     break;
 9435   
             }
 9436  1240 
 
 9437  4882 
             switch (alt70) {
 9438   
                 case 1 :
 9439  1240 
                     // com\\googlecode\\sparkleg\\Sparql.g:320:30: '.'
 9440  1240 
                     {
 9441  490 
                     char_literal210=(Token)match(input,DOT,FOLLOW_DOT_in_groupGraphPatternSubDetail2534);
 9442  490 
                     stream_DOT.add(char_literal210);
 9443  196 
 
 9444   
 
 9445   
                     }
 9446   
                     break;
 9447   
 
 9448  1240 
             }
 9449   
 
 9450   
 
 9451   
             // com\\googlecode\\sparkleg\\Sparql.g:320:35: ( triplesBlock )?
 9452  5078 
             int alt71=2;
 9453  5078 
             switch ( input.LA(1) ) {
 9454   
                 case BLANK_NODE_LABEL:
 9455   
                 case DECIMAL:
 9456   
                 case DECIMAL_NEGATIVE:
 9457   
                 case DECIMAL_POSITIVE:
 9458   
                 case DOUBLE:
 9459   
                 case DOUBLE_NEGATIVE:
 9460   
                 case DOUBLE_POSITIVE:
 9461   
                 case FALSE:
 9462   
                 case INTEGER:
 9463  1240 
                 case INTEGER_NEGATIVE:
 9464  1240 
                 case INTEGER_POSITIVE:
 9465   
                 case IRI_REF:
 9466   
                 case PNAME_LN:
 9467   
                 case PNAME_NS:
 9468   
                 case STRING_LITERAL1:
 9469   
                 case STRING_LITERAL2:
 9470   
                 case STRING_LITERAL_LONG1:
 9471   
                 case STRING_LITERAL_LONG2:
 9472   
                 case TRUE:
 9473   
                 case VAR1:
 9474   
                 case VAR2:
 9475   
                 case 209:
 9476   
                 case 213:
 9477   
                     {
 9478  318 
                     alt71=1;
 9479   
                     }
 9480   
                     break;
 9481   
             }
 9482   
 
 9483  4882 
             switch (alt71) {
 9484   
                 case 1 :
 9485   
                     // com\\googlecode\\sparkleg\\Sparql.g:320:35: triplesBlock
 9486   
                     {
 9487  318 
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2537);
 9488  318 
                     triplesBlock211=triplesBlock();
 9489  84 
 
 9490  318 
                     state._fsp--;
 9491   
 
 9492  318 
                     stream_triplesBlock.add(triplesBlock211.getTree());
 9493   
 
 9494  1240 
                     }
 9495   
                     break;
 9496   
 
 9497   
             }
 9498  84 
 
 9499  84 
 
 9500   
             // AST REWRITE
 9501  84 
             // elements: graphPatternNotTriples, triplesBlock
 9502   
             // token labels:
 9503  84 
             // rule labels: retval
 9504   
             // token list labels:
 9505   
             // rule list labels:
 9506   
             // wildcard labels:
 9507  4882 
             retval.tree = root_0;
 9508  4882 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9509   
 
 9510  4882 
             root_0 = (Object)adaptor.nil();
 9511   
             // 320:49: -> graphPatternNotTriples ( triplesBlock )?
 9512   
             {
 9513  4882 
                 adaptor.addChild(root_0, stream_graphPatternNotTriples.nextTree());
 9514   
 
 9515   
                 // com\\googlecode\\sparkleg\\Sparql.g:320:75: ( triplesBlock )?
 9516  4882 
                 if ( stream_triplesBlock.hasNext() ) {
 9517  318 
                     adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9518  1240 
 
 9519  1240 
                 }
 9520  4882 
                 stream_triplesBlock.reset();
 9521  1240 
 
 9522   
             }
 9523   
 
 9524  1240 
 
 9525  4882 
             retval.tree = root_0;
 9526   
 
 9527  1240 
             }
 9528  84 
 
 9529  4882 
             retval.stop = input.LT(-1);
 9530   
 
 9531  1240 
 
 9532  4882 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9533  4882 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9534   
 
 9535   
         }
 9536  1240 
         catch (RecognitionException re) {
 9537  0 
             reportError(re);
 9538  0 
             recover(input,re);
 9539  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9540  1240 
 
 9541   
         }
 9542   
 
 9543  1240 
         finally {
 9544  1240 
                 // do for sure before leaving
 9545  4882 
         }
 9546  4882 
         return retval;
 9547   
     }
 9548   
     // $ANTLR end "groupGraphPatternSubDetail"
 9549   
 
 9550   
 
 9551  9374 
     public static class triplesBlock_return extends ParserRuleReturnScope {
 9552   
         Object tree;
 9553  9374 
         public Object getTree() { return tree; }
 9554   
     };
 9555   
 
 9556  1240 
 
 9557  1240 
     // $ANTLR start "triplesBlock"
 9558   
     // com\\googlecode\\sparkleg\\Sparql.g:323:1: triplesBlock : triplesSameSubjectPath ( '.' triplesSameSubjectPath )* ( '.' )? -> ( triplesSameSubjectPath )+ ;
 9559   
     public final SparqlParser.triplesBlock_return triplesBlock() throws RecognitionException {
 9560  9374 
         SparqlParser.triplesBlock_return retval = new SparqlParser.triplesBlock_return();
 9561  9374 
         retval.start = input.LT(1);
 9562  2378 
 
 9563   
 
 9564  2378 
         Object root_0 = null;
 9565   
 
 9566  9374 
         Token char_literal213=null;
 9567  9374 
         Token char_literal215=null;
 9568  9374 
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath212 =null;
 9569   
 
 9570  9374 
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath214 =null;
 9571  2378 
 
 9572  2378 
 
 9573  9374 
         Object char_literal213_tree=null;
 9574  9374 
         Object char_literal215_tree=null;
 9575  11752 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9576  9374 
         RewriteRuleSubtreeStream stream_triplesSameSubjectPath=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubjectPath");
 9577  2378 
         try {
 9578  2378 
             // com\\googlecode\\sparkleg\\Sparql.g:324:5: ( triplesSameSubjectPath ( '.' triplesSameSubjectPath )* ( '.' )? -> ( triplesSameSubjectPath )+ )
 9579  2378 
             // com\\googlecode\\sparkleg\\Sparql.g:324:7: triplesSameSubjectPath ( '.' triplesSameSubjectPath )* ( '.' )?
 9580   
             {
 9581  11752 
             pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2562);
 9582  9374 
             triplesSameSubjectPath212=triplesSameSubjectPath();
 9583   
 
 9584  11752 
             state._fsp--;
 9585  2378 
 
 9586  11752 
             stream_triplesSameSubjectPath.add(triplesSameSubjectPath212.getTree());
 9587  2378 
 
 9588   
             // com\\googlecode\\sparkleg\\Sparql.g:324:30: ( '.' triplesSameSubjectPath )*
 9589   
             loop72:
 9590   
             do {
 9591  11634 
                 int alt72=2;
 9592  14012 
                 switch ( input.LA(1) ) {
 9593  2378 
                 case DOT:
 9594   
                     {
 9595  6908 
                     switch ( input.LA(2) ) {
 9596   
                     case BLANK_NODE_LABEL:
 9597  2378 
                     case DECIMAL:
 9598   
                     case DECIMAL_NEGATIVE:
 9599   
                     case DECIMAL_POSITIVE:
 9600   
                     case DOUBLE:
 9601   
                     case DOUBLE_NEGATIVE:
 9602  2946 
                     case DOUBLE_POSITIVE:
 9603  2946 
                     case FALSE:
 9604   
                     case INTEGER:
 9605   
                     case INTEGER_NEGATIVE:
 9606  1482 
                     case INTEGER_POSITIVE:
 9607   
                     case IRI_REF:
 9608   
                     case PNAME_LN:
 9609   
                     case PNAME_NS:
 9610   
                     case STRING_LITERAL1:
 9611   
                     case STRING_LITERAL2:
 9612   
                     case STRING_LITERAL_LONG1:
 9613   
                     case STRING_LITERAL_LONG2:
 9614   
                     case TRUE:
 9615   
                     case VAR1:
 9616   
                     case VAR2:
 9617   
                     case 209:
 9618   
                     case 213:
 9619   
                         {
 9620  2260 
                         alt72=1;
 9621   
                         }
 9622   
                         break;
 9623   
 
 9624   
                     }
 9625   
 
 9626   
                     }
 9627   
                     break;
 9628   
 
 9629   
                 }
 9630   
 
 9631  12202 
                 switch (alt72) {
 9632   
                     case 1 :
 9633   
                         // com\\googlecode\\sparkleg\\Sparql.g:324:31: '.' triplesSameSubjectPath
 9634   
                         {
 9635  2260 
                         char_literal213=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2565);
 9636  2260 
                         stream_DOT.add(char_literal213);
 9637   
 
 9638   
 
 9639  2260 
                         pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2567);
 9640  2260 
                         triplesSameSubjectPath214=triplesSameSubjectPath();
 9641   
 
 9642  5206 
                         state._fsp--;
 9643   
 
 9644  2260 
                         stream_triplesSameSubjectPath.add(triplesSameSubjectPath214.getTree());
 9645   
 
 9646  568 
                         }
 9647  2828 
                         break;
 9648   
 
 9649   
                     default :
 9650  9942 
                         break loop72;
 9651  568 
                 }
 9652  2260 
             } while (true);
 9653  568 
 
 9654   
 
 9655  568 
             // com\\googlecode\\sparkleg\\Sparql.g:324:60: ( '.' )?
 9656  9374 
             int alt73=2;
 9657  9374 
             switch ( input.LA(1) ) {
 9658  568 
                 case DOT:
 9659   
                     {
 9660  2270 
                     alt73=1;
 9661  2378 
                     }
 9662   
                     break;
 9663  568 
             }
 9664   
 
 9665  9374 
             switch (alt73) {
 9666   
                 case 1 :
 9667  2378 
                     // com\\googlecode\\sparkleg\\Sparql.g:324:60: '.'
 9668  2378 
                     {
 9669  2270 
                     char_literal215=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2571);
 9670  2270 
                     stream_DOT.add(char_literal215);
 9671  914 
 
 9672   
 
 9673   
                     }
 9674   
                     break;
 9675   
 
 9676  2378 
             }
 9677   
 
 9678   
 
 9679   
             // AST REWRITE
 9680  914 
             // elements: triplesSameSubjectPath
 9681  914 
             // token labels:
 9682   
             // rule labels: retval
 9683   
             // token list labels:
 9684   
             // rule list labels:
 9685   
             // wildcard labels:
 9686  9374 
             retval.tree = root_0;
 9687  9374 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9688   
 
 9689  9374 
             root_0 = (Object)adaptor.nil();
 9690   
             // 324:65: -> ( triplesSameSubjectPath )+
 9691   
             {
 9692  9374 
                 if ( !(stream_triplesSameSubjectPath.hasNext()) ) {
 9693  0 
                     throw new RewriteEarlyExitException();
 9694   
                 }
 9695  21008 
                 while ( stream_triplesSameSubjectPath.hasNext() ) {
 9696  11634 
                     adaptor.addChild(root_0, stream_triplesSameSubjectPath.nextTree());
 9697  2378 
 
 9698  2378 
                 }
 9699  9374 
                 stream_triplesSameSubjectPath.reset();
 9700  2378 
 
 9701   
             }
 9702   
 
 9703  2378 
 
 9704  9374 
             retval.tree = root_0;
 9705   
 
 9706  5324 
             }
 9707  2946 
 
 9708  9374 
             retval.stop = input.LT(-1);
 9709   
 
 9710  2378 
 
 9711  9374 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9712  9374 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9713   
 
 9714   
         }
 9715  2378 
         catch (RecognitionException re) {
 9716  0 
             reportError(re);
 9717  0 
             recover(input,re);
 9718  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9719  2378 
 
 9720   
         }
 9721   
 
 9722  2378 
         finally {
 9723  2378 
                 // do for sure before leaving
 9724  9374 
         }
 9725  9374 
         return retval;
 9726   
     }
 9727   
     // $ANTLR end "triplesBlock"
 9728   
 
 9729   
 
 9730  4882 
     public static class graphPatternNotTriples_return extends ParserRuleReturnScope {
 9731   
         Object tree;
 9732  4882 
         public Object getTree() { return tree; }
 9733   
     };
 9734   
 
 9735  2378 
 
 9736  2378 
     // $ANTLR start "graphPatternNotTriples"
 9737   
     // com\\googlecode\\sparkleg\\Sparql.g:327:1: graphPatternNotTriples : ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind );
 9738   
     public final SparqlParser.graphPatternNotTriples_return graphPatternNotTriples() throws RecognitionException {
 9739  4882 
         SparqlParser.graphPatternNotTriples_return retval = new SparqlParser.graphPatternNotTriples_return();
 9740  4882 
         retval.start = input.LT(1);
 9741  1240 
 
 9742   
 
 9743  4882 
         Object root_0 = null;
 9744   
 
 9745  4882 
         SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern216 =null;
 9746   
 
 9747  4882 
         SparqlParser.optionalGraphPattern_return optionalGraphPattern217 =null;
 9748   
 
 9749  4882 
         SparqlParser.minusGraphPattern_return minusGraphPattern218 =null;
 9750  1240 
 
 9751  6122 
         SparqlParser.graphGraphPattern_return graphGraphPattern219 =null;
 9752   
 
 9753  4882 
         SparqlParser.serviceGraphPattern_return serviceGraphPattern220 =null;
 9754  1240 
 
 9755  4882 
         SparqlParser.filter_return filter221 =null;
 9756  1240 
 
 9757  4882 
         SparqlParser.bind_return bind222 =null;
 9758  1240 
 
 9759   
 
 9760  1240 
 
 9761   
         try {
 9762  1240 
             // com\\googlecode\\sparkleg\\Sparql.g:328:5: ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind )
 9763  4882 
             int alt74=7;
 9764  6122 
             switch ( input.LA(1) ) {
 9765   
             case 216:
 9766  1240 
                 {
 9767  706 
                 alt74=1;
 9768  1240 
                 }
 9769  706 
                 break;
 9770   
             case OPTIONAL:
 9771   
                 {
 9772  758 
                 alt74=2;
 9773   
                 }
 9774  1998 
                 break;
 9775  1240 
             case MINUS_KEYWORD:
 9776   
                 {
 9777  168 
                 alt74=3;
 9778  178 
                 }
 9779  168 
                 break;
 9780  178 
             case GRAPH:
 9781   
                 {
 9782  604 
                 alt74=4;
 9783  194 
                 }
 9784  604 
                 break;
 9785  194 
             case SERVICE:
 9786   
                 {
 9787  104 
                 alt74=5;
 9788  42 
                 }
 9789  104 
                 break;
 9790  42 
             case FILTER:
 9791   
                 {
 9792  2342 
                 alt74=6;
 9793  154 
                 }
 9794  2342 
                 break;
 9795  154 
             case BIND:
 9796   
                 {
 9797  200 
                 alt74=7;
 9798  26 
                 }
 9799  200 
                 break;
 9800  26 
             default:
 9801  0 
                 NoViableAltException nvae =
 9802   
                     new NoViableAltException("", 74, 0, input);
 9803  596 
 
 9804  0 
                 throw nvae;
 9805  596 
 
 9806   
             }
 9807   
 
 9808  4932 
             switch (alt74) {
 9809   
                 case 1 :
 9810  50 
                     // com\\googlecode\\sparkleg\\Sparql.g:328:7: groupOrUnionGraphPattern
 9811   
                     {
 9812  706 
                     root_0 = (Object)adaptor.nil();
 9813   
 
 9814   
 
 9815  706 
                     pushFollow(FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2594);
 9816  706 
                     groupOrUnionGraphPattern216=groupOrUnionGraphPattern();
 9817   
 
 9818  706 
                     state._fsp--;
 9819  1240 
 
 9820  706 
                     adaptor.addChild(root_0, groupOrUnionGraphPattern216.getTree());
 9821   
 
 9822   
                     }
 9823  884 
                     break;
 9824   
                 case 2 :
 9825   
                     // com\\googlecode\\sparkleg\\Sparql.g:328:34: optionalGraphPattern
 9826  178 
                     {
 9827  936 
                     root_0 = (Object)adaptor.nil();
 9828   
 
 9829  178 
 
 9830  758 
                     pushFollow(FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2598);
 9831  936 
                     optionalGraphPattern217=optionalGraphPattern();
 9832   
 
 9833  758 
                     state._fsp--;
 9834  178 
 
 9835  758 
                     adaptor.addChild(root_0, optionalGraphPattern217.getTree());
 9836   
 
 9837   
                     }
 9838  952 
                     break;
 9839   
                 case 3 :
 9840   
                     // com\\googlecode\\sparkleg\\Sparql.g:328:57: minusGraphPattern
 9841  194 
                     {
 9842  362 
                     root_0 = (Object)adaptor.nil();
 9843   
 
 9844  194 
 
 9845  168 
                     pushFollow(FOLLOW_minusGraphPattern_in_graphPatternNotTriples2602);
 9846  362 
                     minusGraphPattern218=minusGraphPattern();
 9847   
 
 9848  168 
                     state._fsp--;
 9849  194 
 
 9850  168 
                     adaptor.addChild(root_0, minusGraphPattern218.getTree());
 9851   
 
 9852   
                     }
 9853  210 
                     break;
 9854   
                 case 4 :
 9855   
                     // com\\googlecode\\sparkleg\\Sparql.g:328:77: graphGraphPattern
 9856  42 
                     {
 9857  646 
                     root_0 = (Object)adaptor.nil();
 9858   
 
 9859  42 
 
 9860  604 
                     pushFollow(FOLLOW_graphGraphPattern_in_graphPatternNotTriples2606);
 9861  646 
                     graphGraphPattern219=graphGraphPattern();
 9862   
 
 9863  604 
                     state._fsp--;
 9864  42 
 
 9865  604 
                     adaptor.addChild(root_0, graphGraphPattern219.getTree());
 9866   
 
 9867   
                     }
 9868  758 
                     break;
 9869   
                 case 5 :
 9870   
                     // com\\googlecode\\sparkleg\\Sparql.g:328:97: serviceGraphPattern
 9871  154 
                     {
 9872  258 
                     root_0 = (Object)adaptor.nil();
 9873   
 
 9874  154 
 
 9875  104 
                     pushFollow(FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2610);
 9876  258 
                     serviceGraphPattern220=serviceGraphPattern();
 9877   
 
 9878  104 
                     state._fsp--;
 9879  154 
 
 9880  104 
                     adaptor.addChild(root_0, serviceGraphPattern220.getTree());
 9881   
 
 9882   
                     }
 9883  130 
                     break;
 9884   
                 case 6 :
 9885   
                     // com\\googlecode\\sparkleg\\Sparql.g:328:119: filter
 9886  26 
                     {
 9887  2368 
                     root_0 = (Object)adaptor.nil();
 9888   
 
 9889  26 
 
 9890  2342 
                     pushFollow(FOLLOW_filter_in_graphPatternNotTriples2614);
 9891  2368 
                     filter221=filter();
 9892   
 
 9893  2342 
                     state._fsp--;
 9894  26 
 
 9895  2342 
                     adaptor.addChild(root_0, filter221.getTree());
 9896   
 
 9897   
                     }
 9898  2938 
                     break;
 9899   
                 case 7 :
 9900   
                     // com\\googlecode\\sparkleg\\Sparql.g:328:128: bind
 9901  596 
                     {
 9902  796 
                     root_0 = (Object)adaptor.nil();
 9903   
 
 9904  596 
 
 9905  200 
                     pushFollow(FOLLOW_bind_in_graphPatternNotTriples2618);
 9906  796 
                     bind222=bind();
 9907   
 
 9908  200 
                     state._fsp--;
 9909  596 
 
 9910  200 
                     adaptor.addChild(root_0, bind222.getTree());
 9911   
 
 9912   
                     }
 9913  50 
                     break;
 9914   
 
 9915   
             }
 9916  4932 
             retval.stop = input.LT(-1);
 9917  50 
 
 9918   
 
 9919  4932 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9920  4882 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9921  50 
 
 9922   
         }
 9923  0 
         catch (RecognitionException re) {
 9924  0 
             reportError(re);
 9925  0 
             recover(input,re);
 9926  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9927  1240 
 
 9928   
         }
 9929   
 
 9930  1240 
         finally {
 9931  1240 
                 // do for sure before leaving
 9932  4882 
         }
 9933  4882 
         return retval;
 9934   
     }
 9935   
     // $ANTLR end "graphPatternNotTriples"
 9936   
 
 9937   
 
 9938  758 
     public static class optionalGraphPattern_return extends ParserRuleReturnScope {
 9939   
         Object tree;
 9940  758 
         public Object getTree() { return tree; }
 9941   
     };
 9942   
 
 9943  1240 
 
 9944  1240 
     // $ANTLR start "optionalGraphPattern"
 9945   
     // com\\googlecode\\sparkleg\\Sparql.g:331:1: optionalGraphPattern : OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) ;
 9946   
     public final SparqlParser.optionalGraphPattern_return optionalGraphPattern() throws RecognitionException {
 9947  758 
         SparqlParser.optionalGraphPattern_return retval = new SparqlParser.optionalGraphPattern_return();
 9948  758 
         retval.start = input.LT(1);
 9949  194 
 
 9950   
 
 9951  758 
         Object root_0 = null;
 9952   
 
 9953  758 
         Token OPTIONAL223=null;
 9954  758 
         SparqlParser.groupGraphPattern_return groupGraphPattern224 =null;
 9955   
 
 9956   
 
 9957  758 
         Object OPTIONAL223_tree=null;
 9958  952 
         RewriteRuleTokenStream stream_OPTIONAL=new RewriteRuleTokenStream(adaptor,"token OPTIONAL");
 9959  952 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9960   
         try {
 9961   
             // com\\googlecode\\sparkleg\\Sparql.g:332:5: ( OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) )
 9962  194 
             // com\\googlecode\\sparkleg\\Sparql.g:332:7: OPTIONAL groupGraphPattern
 9963   
             {
 9964  952 
             OPTIONAL223=(Token)match(input,OPTIONAL,FOLLOW_OPTIONAL_in_optionalGraphPattern2635);
 9965  952 
             stream_OPTIONAL.add(OPTIONAL223);
 9966   
 
 9967   
 
 9968  952 
             pushFollow(FOLLOW_groupGraphPattern_in_optionalGraphPattern2637);
 9969  952 
             groupGraphPattern224=groupGraphPattern();
 9970  194 
 
 9971  758 
             state._fsp--;
 9972   
 
 9973  758 
             stream_groupGraphPattern.add(groupGraphPattern224.getTree());
 9974   
 
 9975  194 
             // AST REWRITE
 9976  194 
             // elements: groupGraphPattern, OPTIONAL
 9977   
             // token labels:
 9978   
             // rule labels: retval
 9979  194 
             // token list labels:
 9980  194 
             // rule list labels:
 9981   
             // wildcard labels:
 9982  952 
             retval.tree = root_0;
 9983  758 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9984  194 
 
 9985  758 
             root_0 = (Object)adaptor.nil();
 9986   
             // 332:34: -> ^( OPTIONAL groupGraphPattern )
 9987   
             {
 9988   
                 // com\\googlecode\\sparkleg\\Sparql.g:332:37: ^( OPTIONAL groupGraphPattern )
 9989   
                 {
 9990  758 
                 Object root_1 = (Object)adaptor.nil();
 9991  758 
                 root_1 = (Object)adaptor.becomeRoot(
 9992   
                 stream_OPTIONAL.nextNode()
 9993  194 
                 , root_1);
 9994  194 
 
 9995  758 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 9996  194 
 
 9997  758 
                 adaptor.addChild(root_0, root_1);
 9998   
                 }
 9999   
 
 10000   
             }
 10001  194 
 
 10002  194 
 
 10003  758 
             retval.tree = root_0;
 10004   
 
 10005   
             }
 10006  194 
 
 10007  758 
             retval.stop = input.LT(-1);
 10008  194 
 
 10009   
 
 10010  758 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10011  758 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10012   
 
 10013   
         }
 10014  194 
         catch (RecognitionException re) {
 10015  0 
             reportError(re);
 10016  0 
             recover(input,re);
 10017  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10018  194 
 
 10019   
         }
 10020   
 
 10021  194 
         finally {
 10022  194 
                 // do for sure before leaving
 10023  758 
         }
 10024  758 
         return retval;
 10025   
     }
 10026   
     // $ANTLR end "optionalGraphPattern"
 10027   
 
 10028   
 
 10029  604 
     public static class graphGraphPattern_return extends ParserRuleReturnScope {
 10030   
         Object tree;
 10031  604 
         public Object getTree() { return tree; }
 10032   
     };
 10033   
 
 10034  194 
 
 10035  194 
     // $ANTLR start "graphGraphPattern"
 10036   
     // com\\googlecode\\sparkleg\\Sparql.g:335:1: graphGraphPattern : GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) ;
 10037   
     public final SparqlParser.graphGraphPattern_return graphGraphPattern() throws RecognitionException {
 10038  604 
         SparqlParser.graphGraphPattern_return retval = new SparqlParser.graphGraphPattern_return();
 10039  604 
         retval.start = input.LT(1);
 10040  154 
 
 10041   
 
 10042  154 
         Object root_0 = null;
 10043   
 
 10044  604 
         Token GRAPH225=null;
 10045  604 
         SparqlParser.varOrIRIref_return varOrIRIref226 =null;
 10046   
 
 10047  604 
         SparqlParser.groupGraphPattern_return groupGraphPattern227 =null;
 10048   
 
 10049  154 
 
 10050  758 
         Object GRAPH225_tree=null;
 10051  604 
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 10052  604 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 10053  758 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10054   
         try {
 10055  154 
             // com\\googlecode\\sparkleg\\Sparql.g:336:5: ( GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) )
 10056  154 
             // com\\googlecode\\sparkleg\\Sparql.g:336:7: GRAPH varOrIRIref groupGraphPattern
 10057   
             {
 10058  758 
             GRAPH225=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphGraphPattern2662);
 10059  604 
             stream_GRAPH.add(GRAPH225);
 10060   
 
 10061  154 
 
 10062  758 
             pushFollow(FOLLOW_varOrIRIref_in_graphGraphPattern2664);
 10063  758 
             varOrIRIref226=varOrIRIref();
 10064  154 
 
 10065  604 
             state._fsp--;
 10066   
 
 10067  604 
             stream_varOrIRIref.add(varOrIRIref226.getTree());
 10068   
 
 10069  758 
             pushFollow(FOLLOW_groupGraphPattern_in_graphGraphPattern2666);
 10070  758 
             groupGraphPattern227=groupGraphPattern();
 10071   
 
 10072  604 
             state._fsp--;
 10073  154 
 
 10074  758 
             stream_groupGraphPattern.add(groupGraphPattern227.getTree());
 10075   
 
 10076  154 
             // AST REWRITE
 10077   
             // elements: varOrIRIref, groupGraphPattern, GRAPH
 10078  154 
             // token labels:
 10079   
             // rule labels: retval
 10080  154 
             // token list labels:
 10081  154 
             // rule list labels:
 10082   
             // wildcard labels:
 10083  758 
             retval.tree = root_0;
 10084  604 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10085  154 
 
 10086  604 
             root_0 = (Object)adaptor.nil();
 10087   
             // 336:43: -> ^( GRAPH varOrIRIref groupGraphPattern )
 10088   
             {
 10089   
                 // com\\googlecode\\sparkleg\\Sparql.g:336:46: ^( GRAPH varOrIRIref groupGraphPattern )
 10090   
                 {
 10091  604 
                 Object root_1 = (Object)adaptor.nil();
 10092  604 
                 root_1 = (Object)adaptor.becomeRoot(
 10093   
                 stream_GRAPH.nextNode()
 10094  154 
                 , root_1);
 10095  154 
 
 10096  604 
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10097  154 
 
 10098  604 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10099   
 
 10100  604 
                 adaptor.addChild(root_0, root_1);
 10101   
                 }
 10102  154 
 
 10103  154 
             }
 10104   
 
 10105   
 
 10106  604 
             retval.tree = root_0;
 10107  154 
 
 10108   
             }
 10109  154 
 
 10110  604 
             retval.stop = input.LT(-1);
 10111  154 
 
 10112   
 
 10113  604 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10114  604 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10115   
 
 10116   
         }
 10117  154 
         catch (RecognitionException re) {
 10118  0 
             reportError(re);
 10119  0 
             recover(input,re);
 10120  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10121  154 
 
 10122   
         }
 10123   
 
 10124  154 
         finally {
 10125  154 
                 // do for sure before leaving
 10126  604 
         }
 10127  604 
         return retval;
 10128   
     }
 10129   
     // $ANTLR end "graphGraphPattern"
 10130   
 
 10131   
 
 10132  104 
     public static class serviceGraphPattern_return extends ParserRuleReturnScope {
 10133   
         Object tree;
 10134  104 
         public Object getTree() { return tree; }
 10135   
     };
 10136   
 
 10137  154 
 
 10138  154 
     // $ANTLR start "serviceGraphPattern"
 10139   
     // com\\googlecode\\sparkleg\\Sparql.g:339:1: serviceGraphPattern : SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) ;
 10140   
     public final SparqlParser.serviceGraphPattern_return serviceGraphPattern() throws RecognitionException {
 10141  104 
         SparqlParser.serviceGraphPattern_return retval = new SparqlParser.serviceGraphPattern_return();
 10142  104 
         retval.start = input.LT(1);
 10143  26 
 
 10144   
 
 10145  104 
         Object root_0 = null;
 10146   
 
 10147  104 
         Token SERVICE228=null;
 10148  104 
         Token SILENT229=null;
 10149  104 
         SparqlParser.varOrIRIref_return varOrIRIref230 =null;
 10150   
 
 10151  104 
         SparqlParser.groupGraphPattern_return groupGraphPattern231 =null;
 10152  26 
 
 10153  26 
 
 10154  104 
         Object SERVICE228_tree=null;
 10155  104 
         Object SILENT229_tree=null;
 10156  130 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 10157  104 
         RewriteRuleTokenStream stream_SERVICE=new RewriteRuleTokenStream(adaptor,"token SERVICE");
 10158  130 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 10159  130 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10160  26 
         try {
 10161   
             // com\\googlecode\\sparkleg\\Sparql.g:340:5: ( SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) )
 10162  26 
             // com\\googlecode\\sparkleg\\Sparql.g:340:7: SERVICE ( SILENT )? varOrIRIref groupGraphPattern
 10163   
             {
 10164  104 
             SERVICE228=(Token)match(input,SERVICE,FOLLOW_SERVICE_in_serviceGraphPattern2693);
 10165  130 
             stream_SERVICE.add(SERVICE228);
 10166  26 
 
 10167  26 
 
 10168  26 
             // com\\googlecode\\sparkleg\\Sparql.g:340:15: ( SILENT )?
 10169  130 
             int alt75=2;
 10170  130 
             switch ( input.LA(1) ) {
 10171   
                 case SILENT:
 10172   
                     {
 10173  24 
                     alt75=1;
 10174   
                     }
 10175  26 
                     break;
 10176  26 
             }
 10177   
 
 10178  104 
             switch (alt75) {
 10179   
                 case 1 :
 10180  26 
                     // com\\googlecode\\sparkleg\\Sparql.g:340:15: SILENT
 10181  26 
                     {
 10182  24 
                     SILENT229=(Token)match(input,SILENT,FOLLOW_SILENT_in_serviceGraphPattern2695);
 10183  24 
                     stream_SILENT.add(SILENT229);
 10184  6 
 
 10185   
 
 10186   
                     }
 10187   
                     break;
 10188   
 
 10189  26 
             }
 10190   
 
 10191   
 
 10192  104 
             pushFollow(FOLLOW_varOrIRIref_in_serviceGraphPattern2698);
 10193  110 
             varOrIRIref230=varOrIRIref();
 10194  6 
 
 10195  104 
             state._fsp--;
 10196   
 
 10197  104 
             stream_varOrIRIref.add(varOrIRIref230.getTree());
 10198   
 
 10199  104 
             pushFollow(FOLLOW_groupGraphPattern_in_serviceGraphPattern2700);
 10200  104 
             groupGraphPattern231=groupGraphPattern();
 10201   
 
 10202  104 
             state._fsp--;
 10203  26 
 
 10204  130 
             stream_groupGraphPattern.add(groupGraphPattern231.getTree());
 10205   
 
 10206  26 
             // AST REWRITE
 10207   
             // elements: SERVICE, groupGraphPattern, varOrIRIref, SILENT
 10208  26 
             // token labels:
 10209   
             // rule labels: retval
 10210  26 
             // token list labels:
 10211  26 
             // rule list labels:
 10212   
             // wildcard labels:
 10213  130 
             retval.tree = root_0;
 10214  104 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10215  26 
 
 10216  104 
             root_0 = (Object)adaptor.nil();
 10217   
             // 340:53: -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10218   
             {
 10219   
                 // com\\googlecode\\sparkleg\\Sparql.g:340:56: ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10220   
                 {
 10221  104 
                 Object root_1 = (Object)adaptor.nil();
 10222  104 
                 root_1 = (Object)adaptor.becomeRoot(
 10223   
                 stream_SERVICE.nextNode()
 10224  26 
                 , root_1);
 10225  26 
 
 10226   
                 // com\\googlecode\\sparkleg\\Sparql.g:340:66: ( SILENT )?
 10227  130 
                 if ( stream_SILENT.hasNext() ) {
 10228  24 
                     adaptor.addChild(root_1,
 10229   
                     stream_SILENT.nextNode()
 10230   
                     );
 10231   
 
 10232  26 
                 }
 10233  130 
                 stream_SILENT.reset();
 10234   
 
 10235  104 
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10236   
 
 10237  104 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10238  26 
 
 10239  110 
                 adaptor.addChild(root_0, root_1);
 10240   
                 }
 10241   
 
 10242   
             }
 10243   
 
 10244  26 
 
 10245  104 
             retval.tree = root_0;
 10246  26 
 
 10247   
             }
 10248  26 
 
 10249  104 
             retval.stop = input.LT(-1);
 10250  26 
 
 10251   
 
 10252  104 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10253  104 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10254   
 
 10255   
         }
 10256  26 
         catch (RecognitionException re) {
 10257  0 
             reportError(re);
 10258  0 
             recover(input,re);
 10259  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10260  26 
 
 10261   
         }
 10262   
 
 10263  26 
         finally {
 10264  26 
                 // do for sure before leaving
 10265  104 
         }
 10266  104 
         return retval;
 10267   
     }
 10268   
     // $ANTLR end "serviceGraphPattern"
 10269   
 
 10270   
 
 10271  200 
     public static class bind_return extends ParserRuleReturnScope {
 10272   
         Object tree;
 10273  200 
         public Object getTree() { return tree; }
 10274   
     };
 10275   
 
 10276  26 
 
 10277  26 
     // $ANTLR start "bind"
 10278   
     // com\\googlecode\\sparkleg\\Sparql.g:343:1: bind : BIND '(' expression AS var ')' -> ^( BIND expression ^( AS var ) ) ;
 10279   
     public final SparqlParser.bind_return bind() throws RecognitionException {
 10280  200 
         SparqlParser.bind_return retval = new SparqlParser.bind_return();
 10281  200 
         retval.start = input.LT(1);
 10282  50 
 
 10283   
 
 10284  200 
         Object root_0 = null;
 10285   
 
 10286  200 
         Token BIND232=null;
 10287  200 
         Token char_literal233=null;
 10288  200 
         Token AS235=null;
 10289  200 
         Token char_literal237=null;
 10290  200 
         SparqlParser.expression_return expression234 =null;
 10291  50 
 
 10292  250 
         SparqlParser.var_return var236 =null;
 10293   
 
 10294   
 
 10295  250 
         Object BIND232_tree=null;
 10296  200 
         Object char_literal233_tree=null;
 10297  250 
         Object AS235_tree=null;
 10298  250 
         Object char_literal237_tree=null;
 10299  250 
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 10300  250 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 10301  250 
         RewriteRuleTokenStream stream_BIND=new RewriteRuleTokenStream(adaptor,"token BIND");
 10302  200 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 10303  250 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10304  200 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 10305   
         try {
 10306  50 
             // com\\googlecode\\sparkleg\\Sparql.g:344:5: ( BIND '(' expression AS var ')' -> ^( BIND expression ^( AS var ) ) )
 10307  50 
             // com\\googlecode\\sparkleg\\Sparql.g:344:7: BIND '(' expression AS var ')'
 10308  50 
             {
 10309  250 
             BIND232=(Token)match(input,BIND,FOLLOW_BIND_in_bind2734);
 10310  250 
             stream_BIND.add(BIND232);
 10311  50 
 
 10312  50 
 
 10313  250 
             char_literal233=(Token)match(input,209,FOLLOW_209_in_bind2736);
 10314  250 
             stream_209.add(char_literal233);
 10315  50 
 
 10316   
 
 10317  200 
             pushFollow(FOLLOW_expression_in_bind2738);
 10318  200 
             expression234=expression();
 10319   
 
 10320  250 
             state._fsp--;
 10321  50 
 
 10322  200 
             stream_expression.add(expression234.getTree());
 10323   
 
 10324  250 
             AS235=(Token)match(input,AS,FOLLOW_AS_in_bind2740);
 10325  250 
             stream_AS.add(AS235);
 10326   
 
 10327   
 
 10328  250 
             pushFollow(FOLLOW_var_in_bind2742);
 10329  250 
             var236=var();
 10330   
 
 10331  250 
             state._fsp--;
 10332   
 
 10333  250 
             stream_var.add(var236.getTree());
 10334   
 
 10335  250 
             char_literal237=(Token)match(input,210,FOLLOW_210_in_bind2744);
 10336  250 
             stream_210.add(char_literal237);
 10337   
 
 10338   
 
 10339  50 
             // AST REWRITE
 10340  50 
             // elements: BIND, expression, AS, var
 10341   
             // token labels:
 10342  50 
             // rule labels: retval
 10343   
             // token list labels:
 10344  50 
             // rule list labels:
 10345   
             // wildcard labels:
 10346  250 
             retval.tree = root_0;
 10347  250 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10348   
 
 10349  200 
             root_0 = (Object)adaptor.nil();
 10350   
             // 344:38: -> ^( BIND expression ^( AS var ) )
 10351   
             {
 10352   
                 // com\\googlecode\\sparkleg\\Sparql.g:344:41: ^( BIND expression ^( AS var ) )
 10353   
                 {
 10354  200 
                 Object root_1 = (Object)adaptor.nil();
 10355  200 
                 root_1 = (Object)adaptor.becomeRoot(
 10356   
                 stream_BIND.nextNode()
 10357  50 
                 , root_1);
 10358  50 
 
 10359  200 
                 adaptor.addChild(root_1, stream_expression.nextTree());
 10360  50 
 
 10361   
                 // com\\googlecode\\sparkleg\\Sparql.g:344:59: ^( AS var )
 10362   
                 {
 10363  200 
                 Object root_2 = (Object)adaptor.nil();
 10364  200 
                 root_2 = (Object)adaptor.becomeRoot(
 10365  50 
                 stream_AS.nextNode()
 10366  50 
                 , root_2);
 10367   
 
 10368  200 
                 adaptor.addChild(root_2, stream_var.nextTree());
 10369   
 
 10370  250 
                 adaptor.addChild(root_1, root_2);
 10371   
                 }
 10372   
 
 10373  200 
                 adaptor.addChild(root_0, root_1);
 10374  50 
                 }
 10375  50 
 
 10376   
             }
 10377   
 
 10378   
 
 10379  250 
             retval.tree = root_0;
 10380   
 
 10381  50 
             }
 10382   
 
 10383  200 
             retval.stop = input.LT(-1);
 10384  50 
 
 10385   
 
 10386  200 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10387  200 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10388   
 
 10389   
         }
 10390  50 
         catch (RecognitionException re) {
 10391  0 
             reportError(re);
 10392  0 
             recover(input,re);
 10393  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10394  50 
 
 10395   
         }
 10396   
 
 10397  50 
         finally {
 10398  50 
                 // do for sure before leaving
 10399  200 
         }
 10400  200 
         return retval;
 10401   
     }
 10402   
     // $ANTLR end "bind"
 10403   
 
 10404   
 
 10405  168 
     public static class minusGraphPattern_return extends ParserRuleReturnScope {
 10406   
         Object tree;
 10407  168 
         public Object getTree() { return tree; }
 10408   
     };
 10409   
 
 10410  50 
 
 10411  50 
     // $ANTLR start "minusGraphPattern"
 10412   
     // com\\googlecode\\sparkleg\\Sparql.g:347:1: minusGraphPattern : MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) ;
 10413   
     public final SparqlParser.minusGraphPattern_return minusGraphPattern() throws RecognitionException {
 10414  168 
         SparqlParser.minusGraphPattern_return retval = new SparqlParser.minusGraphPattern_return();
 10415  168 
         retval.start = input.LT(1);
 10416  42 
 
 10417   
 
 10418  168 
         Object root_0 = null;
 10419   
 
 10420  168 
         Token MINUS_KEYWORD238=null;
 10421  168 
         SparqlParser.groupGraphPattern_return groupGraphPattern239 =null;
 10422   
 
 10423   
 
 10424  168 
         Object MINUS_KEYWORD238_tree=null;
 10425  210 
         RewriteRuleTokenStream stream_MINUS_KEYWORD=new RewriteRuleTokenStream(adaptor,"token MINUS_KEYWORD");
 10426  210 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10427   
         try {
 10428   
             // com\\googlecode\\sparkleg\\Sparql.g:348:5: ( MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) )
 10429  42 
             // com\\googlecode\\sparkleg\\Sparql.g:348:7: MINUS_KEYWORD groupGraphPattern
 10430   
             {
 10431  210 
             MINUS_KEYWORD238=(Token)match(input,MINUS_KEYWORD,FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2781);
 10432  210 
             stream_MINUS_KEYWORD.add(MINUS_KEYWORD238);
 10433   
 
 10434   
 
 10435  210 
             pushFollow(FOLLOW_groupGraphPattern_in_minusGraphPattern2783);
 10436  210 
             groupGraphPattern239=groupGraphPattern();
 10437  42 
 
 10438  168 
             state._fsp--;
 10439   
 
 10440  168 
             stream_groupGraphPattern.add(groupGraphPattern239.getTree());
 10441   
 
 10442  42 
             // AST REWRITE
 10443  42 
             // elements: groupGraphPattern, MINUS_KEYWORD
 10444   
             // token labels:
 10445   
             // rule labels: retval
 10446  42 
             // token list labels:
 10447  42 
             // rule list labels:
 10448   
             // wildcard labels:
 10449  210 
             retval.tree = root_0;
 10450  168 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10451  42 
 
 10452  168 
             root_0 = (Object)adaptor.nil();
 10453   
             // 348:39: -> ^( MINUS_KEYWORD groupGraphPattern )
 10454   
             {
 10455   
                 // com\\googlecode\\sparkleg\\Sparql.g:348:42: ^( MINUS_KEYWORD groupGraphPattern )
 10456   
                 {
 10457  168 
                 Object root_1 = (Object)adaptor.nil();
 10458  168 
                 root_1 = (Object)adaptor.becomeRoot(
 10459   
                 stream_MINUS_KEYWORD.nextNode()
 10460  42 
                 , root_1);
 10461  42 
 
 10462  168 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10463  42 
 
 10464  168 
                 adaptor.addChild(root_0, root_1);
 10465   
                 }
 10466   
 
 10467   
             }
 10468  42 
 
 10469  42 
 
 10470  168 
             retval.tree = root_0;
 10471   
 
 10472   
             }
 10473  42 
 
 10474  168 
             retval.stop = input.LT(-1);
 10475  42 
 
 10476   
 
 10477  168 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10478  168 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10479   
 
 10480   
         }
 10481  42 
         catch (RecognitionException re) {
 10482  0 
             reportError(re);
 10483  0 
             recover(input,re);
 10484  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10485  42 
 
 10486   
         }
 10487   
 
 10488  42 
         finally {
 10489  42 
                 // do for sure before leaving
 10490  168 
         }
 10491  168 
         return retval;
 10492   
     }
 10493   
     // $ANTLR end "minusGraphPattern"
 10494   
 
 10495   
 
 10496  706 
     public static class groupOrUnionGraphPattern_return extends ParserRuleReturnScope {
 10497   
         Object tree;
 10498  706 
         public Object getTree() { return tree; }
 10499   
     };
 10500   
 
 10501  42 
 
 10502  42 
     // $ANTLR start "groupOrUnionGraphPattern"
 10503   
     // com\\googlecode\\sparkleg\\Sparql.g:351:1: groupOrUnionGraphPattern : (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* ;
 10504   
     public final SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern() throws RecognitionException {
 10505  706 
         SparqlParser.groupOrUnionGraphPattern_return retval = new SparqlParser.groupOrUnionGraphPattern_return();
 10506  706 
         retval.start = input.LT(1);
 10507  178 
 
 10508   
 
 10509  706 
         Object root_0 = null;
 10510   
 
 10511  706 
         Token UNION240=null;
 10512  706 
         SparqlParser.groupGraphPattern_return g1 =null;
 10513   
 
 10514  706 
         SparqlParser.groupGraphPattern_return g2 =null;
 10515   
 
 10516  178 
 
 10517  884 
         Object UNION240_tree=null;
 10518  706 
         RewriteRuleTokenStream stream_UNION=new RewriteRuleTokenStream(adaptor,"token UNION");
 10519  706 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10520  178 
         try {
 10521   
             // com\\googlecode\\sparkleg\\Sparql.g:352:5: ( (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* )
 10522  178 
             // com\\googlecode\\sparkleg\\Sparql.g:352:7: (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10523  178 
             {
 10524   
             // com\\googlecode\\sparkleg\\Sparql.g:352:7: (g1= groupGraphPattern -> $g1)
 10525  178 
             // com\\googlecode\\sparkleg\\Sparql.g:352:8: g1= groupGraphPattern
 10526   
             {
 10527  706 
             pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2811);
 10528  884 
             g1=groupGraphPattern();
 10529  178 
 
 10530  884 
             state._fsp--;
 10531   
 
 10532  706 
             stream_groupGraphPattern.add(g1.getTree());
 10533   
 
 10534   
             // AST REWRITE
 10535   
             // elements: g1
 10536   
             // token labels:
 10537   
             // rule labels: retval, g1
 10538  178 
             // token list labels:
 10539  178 
             // rule list labels:
 10540   
             // wildcard labels:
 10541  884 
             retval.tree = root_0;
 10542  706 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10543  884 
             RewriteRuleSubtreeStream stream_g1=new RewriteRuleSubtreeStream(adaptor,"rule g1",g1!=null?g1.tree:null);
 10544   
 
 10545  706 
             root_0 = (Object)adaptor.nil();
 10546   
             // 352:28: -> $g1
 10547   
             {
 10548  706 
                 adaptor.addChild(root_0, stream_g1.nextTree());
 10549   
 
 10550   
             }
 10551   
 
 10552  178 
 
 10553  884 
             retval.tree = root_0;
 10554  178 
 
 10555   
             }
 10556  178 
 
 10557   
 
 10558   
             // com\\googlecode\\sparkleg\\Sparql.g:352:35: ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10559  178 
             loop76:
 10560   
             do {
 10561  1090 
                 int alt76=2;
 10562  1090 
                 switch ( input.LA(1) ) {
 10563   
                 case UNION:
 10564  178 
                     {
 10565  384 
                     alt76=1;
 10566   
                     }
 10567   
                     break;
 10568   
 
 10569   
                 }
 10570   
 
 10571  1090 
                 switch (alt76) {
 10572  274 
                     case 1 :
 10573  274 
                         // com\\googlecode\\sparkleg\\Sparql.g:352:36: ( UNION g2= groupGraphPattern )
 10574   
                         {
 10575   
                         // com\\googlecode\\sparkleg\\Sparql.g:352:36: ( UNION g2= groupGraphPattern )
 10576  96 
                         // com\\googlecode\\sparkleg\\Sparql.g:352:37: UNION g2= groupGraphPattern
 10577   
                         {
 10578  384 
                         UNION240=(Token)match(input,UNION,FOLLOW_UNION_in_groupOrUnionGraphPattern2819);
 10579  384 
                         stream_UNION.add(UNION240);
 10580   
 
 10581   
 
 10582  658 
                         pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2823);
 10583  384 
                         g2=groupGraphPattern();
 10584   
 
 10585  384 
                         state._fsp--;
 10586   
 
 10587  384 
                         stream_groupGraphPattern.add(g2.getTree());
 10588   
 
 10589  96 
                         }
 10590  96 
 
 10591   
 
 10592   
                         // AST REWRITE
 10593  96 
                         // elements: g2, UNION, groupOrUnionGraphPattern
 10594  96 
                         // token labels:
 10595   
                         // rule labels: retval, g2
 10596  96 
                         // token list labels:
 10597   
                         // rule list labels:
 10598  96 
                         // wildcard labels:
 10599  384 
                         retval.tree = root_0;
 10600  384 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10601  384 
                         RewriteRuleSubtreeStream stream_g2=new RewriteRuleSubtreeStream(adaptor,"rule g2",g2!=null?g2.tree:null);
 10602   
 
 10603  384 
                         root_0 = (Object)adaptor.nil();
 10604   
                         // 352:65: -> ^( UNION $groupOrUnionGraphPattern $g2)
 10605   
                         {
 10606   
                             // com\\googlecode\\sparkleg\\Sparql.g:352:68: ^( UNION $groupOrUnionGraphPattern $g2)
 10607   
                             {
 10608  384 
                             Object root_1 = (Object)adaptor.nil();
 10609  384 
                             root_1 = (Object)adaptor.becomeRoot(
 10610  96 
                             stream_UNION.nextNode()
 10611  96 
                             , root_1);
 10612  96 
 
 10613  384 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 10614  96 
 
 10615  384 
                             adaptor.addChild(root_1, stream_g2.nextTree());
 10616   
 
 10617  384 
                             adaptor.addChild(root_0, root_1);
 10618   
                             }
 10619  96 
 
 10620  96 
                         }
 10621   
 
 10622   
 
 10623  384 
                         retval.tree = root_0;
 10624  96 
 
 10625   
                         }
 10626  480 
                         break;
 10627   
 
 10628  96 
                     default :
 10629  706 
                         break loop76;
 10630   
                 }
 10631  384 
             } while (true);
 10632   
 
 10633   
 
 10634  96 
             }
 10635   
 
 10636  706 
             retval.stop = input.LT(-1);
 10637  96 
 
 10638   
 
 10639  706 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10640  884 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10641   
 
 10642  96 
         }
 10643  0 
         catch (RecognitionException re) {
 10644  0 
             reportError(re);
 10645  0 
             recover(input,re);
 10646  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10647  178 
 
 10648   
         }
 10649   
 
 10650  178 
         finally {
 10651  178 
                 // do for sure before leaving
 10652  706 
         }
 10653  706 
         return retval;
 10654   
     }
 10655   
     // $ANTLR end "groupOrUnionGraphPattern"
 10656   
 
 10657   
 
 10658  2342 
     public static class filter_return extends ParserRuleReturnScope {
 10659   
         Object tree;
 10660  2342 
         public Object getTree() { return tree; }
 10661   
     };
 10662   
 
 10663  178 
 
 10664  178 
     // $ANTLR start "filter"
 10665   
     // com\\googlecode\\sparkleg\\Sparql.g:355:1: filter : FILTER constraint -> ^( FILTER constraint ) ;
 10666   
     public final SparqlParser.filter_return filter() throws RecognitionException {
 10667  2342 
         SparqlParser.filter_return retval = new SparqlParser.filter_return();
 10668  2342 
         retval.start = input.LT(1);
 10669  596 
 
 10670   
 
 10671  596 
         Object root_0 = null;
 10672   
 
 10673  2342 
         Token FILTER241=null;
 10674  2342 
         SparqlParser.constraint_return constraint242 =null;
 10675   
 
 10676   
 
 10677  2342 
         Object FILTER241_tree=null;
 10678  2938 
         RewriteRuleTokenStream stream_FILTER=new RewriteRuleTokenStream(adaptor,"token FILTER");
 10679  2938 
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 10680   
         try {
 10681   
             // com\\googlecode\\sparkleg\\Sparql.g:356:5: ( FILTER constraint -> ^( FILTER constraint ) )
 10682  596 
             // com\\googlecode\\sparkleg\\Sparql.g:356:7: FILTER constraint
 10683   
             {
 10684  2938 
             FILTER241=(Token)match(input,FILTER,FOLLOW_FILTER_in_filter2855);
 10685  2938 
             stream_FILTER.add(FILTER241);
 10686   
 
 10687   
 
 10688  2938 
             pushFollow(FOLLOW_constraint_in_filter2857);
 10689  2938 
             constraint242=constraint();
 10690  596 
 
 10691  2342 
             state._fsp--;
 10692   
 
 10693  2342 
             stream_constraint.add(constraint242.getTree());
 10694   
 
 10695  596 
             // AST REWRITE
 10696  596 
             // elements: constraint, FILTER
 10697   
             // token labels:
 10698   
             // rule labels: retval
 10699  596 
             // token list labels:
 10700  596 
             // rule list labels:
 10701   
             // wildcard labels:
 10702  2938 
             retval.tree = root_0;
 10703  2342 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10704  596 
 
 10705  2342 
             root_0 = (Object)adaptor.nil();
 10706   
             // 356:25: -> ^( FILTER constraint )
 10707   
             {
 10708   
                 // com\\googlecode\\sparkleg\\Sparql.g:356:28: ^( FILTER constraint )
 10709   
                 {
 10710  2342 
                 Object root_1 = (Object)adaptor.nil();
 10711  2342 
                 root_1 = (Object)adaptor.becomeRoot(
 10712   
                 stream_FILTER.nextNode()
 10713  596 
                 , root_1);
 10714  596 
 
 10715  2342 
                 adaptor.addChild(root_1, stream_constraint.nextTree());
 10716  596 
 
 10717  2342 
                 adaptor.addChild(root_0, root_1);
 10718   
                 }
 10719   
 
 10720   
             }
 10721  596 
 
 10722  596 
 
 10723  2342 
             retval.tree = root_0;
 10724   
 
 10725   
             }
 10726  596 
 
 10727  2342 
             retval.stop = input.LT(-1);
 10728  596 
 
 10729   
 
 10730  2342 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10731  2342 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10732   
 
 10733   
         }
 10734  596 
         catch (RecognitionException re) {
 10735  0 
             reportError(re);
 10736  0 
             recover(input,re);
 10737  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10738  596 
 
 10739   
         }
 10740   
 
 10741  596 
         finally {
 10742  596 
                 // do for sure before leaving
 10743  2342 
         }
 10744  2342 
         return retval;
 10745   
     }
 10746   
     // $ANTLR end "filter"
 10747   
 
 10748   
 
 10749  2454 
     public static class constraint_return extends ParserRuleReturnScope {
 10750   
         Object tree;
 10751  2454 
         public Object getTree() { return tree; }
 10752   
     };
 10753   
 
 10754  596 
 
 10755  596 
     // $ANTLR start "constraint"
 10756   
     // com\\googlecode\\sparkleg\\Sparql.g:359:1: constraint : ( brackettedExpression | builtInCall | functionCall );
 10757   
     public final SparqlParser.constraint_return constraint() throws RecognitionException {
 10758  2454 
         SparqlParser.constraint_return retval = new SparqlParser.constraint_return();
 10759  2454 
         retval.start = input.LT(1);
 10760  624 
 
 10761   
 
 10762  2454 
         Object root_0 = null;
 10763   
 
 10764  2454 
         SparqlParser.brackettedExpression_return brackettedExpression243 =null;
 10765   
 
 10766  2454 
         SparqlParser.builtInCall_return builtInCall244 =null;
 10767   
 
 10768  2454 
         SparqlParser.functionCall_return functionCall245 =null;
 10769  624 
 
 10770  624 
 
 10771   
 
 10772   
         try {
 10773  624 
             // com\\googlecode\\sparkleg\\Sparql.g:360:5: ( brackettedExpression | builtInCall | functionCall )
 10774  2454 
             int alt77=3;
 10775  3078 
             switch ( input.LA(1) ) {
 10776   
             case 209:
 10777  624 
                 {
 10778  1788 
                 alt77=1;
 10779  624 
                 }
 10780  1788 
                 break;
 10781   
             case ABS:
 10782   
             case BNODE:
 10783   
             case BOUND:
 10784   
             case CEIL:
 10785  624 
             case COALESCE:
 10786  624 
             case CONCAT:
 10787   
             case CONTAINS:
 10788   
             case DATATYPE:
 10789  456 
             case DAY:
 10790   
             case ENCODE_FOR_URI:
 10791  456 
             case EXISTS:
 10792   
             case FLOOR:
 10793   
             case HOURS:
 10794   
             case IF:
 10795   
             case IRI:
 10796   
             case ISBLANK:
 10797   
             case ISIRI:
 10798   
             case ISLITERAL:
 10799   
             case ISNUMERIC:
 10800   
             case ISURI:
 10801   
             case LANG:
 10802   
             case LANGMATCHES:
 10803   
             case LCASE:
 10804   
             case MD5:
 10805   
             case MINUTES:
 10806   
             case MONTH:
 10807   
             case NOT:
 10808   
             case NOW:
 10809   
             case RAND:
 10810   
             case REGEX:
 10811   
             case REPLACE:
 10812   
             case ROUND:
 10813   
             case SAMETERM:
 10814   
             case SECONDS:
 10815   
             case SHA1:
 10816   
             case SHA256:
 10817   
             case SHA384:
 10818   
             case SHA512:
 10819   
             case STR:
 10820   
             case STRAFTER:
 10821   
             case STRBEFORE:
 10822   
             case STRDT:
 10823   
             case STRENDS:
 10824   
             case STRLANG:
 10825   
             case STRLEN:
 10826   
             case STRSTARTS:
 10827   
             case SUBSTR:
 10828   
             case TIMEZONE:
 10829   
             case TZ:
 10830   
             case UCASE:
 10831   
             case URI:
 10832   
             case YEAR:
 10833   
                 {
 10834  632 
                 alt77=2;
 10835   
                 }
 10836  632 
                 break;
 10837   
             case IRI_REF:
 10838   
             case PNAME_LN:
 10839   
             case PNAME_NS:
 10840   
                 {
 10841  32 
                 alt77=3;
 10842   
                 }
 10843  32 
                 break;
 10844   
             default:
 10845  160 
                 NoViableAltException nvae =
 10846   
                     new NoViableAltException("", 77, 0, input);
 10847  158 
 
 10848  2 
                 throw nvae;
 10849   
 
 10850   
             }
 10851   
 
 10852  2460 
             switch (alt77) {
 10853   
                 case 1 :
 10854  8 
                     // com\\googlecode\\sparkleg\\Sparql.g:360:7: brackettedExpression
 10855   
                     {
 10856  1790 
                     root_0 = (Object)adaptor.nil();
 10857   
 
 10858   
 
 10859  1790 
                     pushFollow(FOLLOW_brackettedExpression_in_constraint2882);
 10860  1788 
                     brackettedExpression243=brackettedExpression();
 10861   
 
 10862  1788 
                     state._fsp--;
 10863  622 
 
 10864  1788 
                     adaptor.addChild(root_0, brackettedExpression243.getTree());
 10865   
 
 10866   
                     }
 10867  2244 
                     break;
 10868   
                 case 2 :
 10869   
                     // com\\googlecode\\sparkleg\\Sparql.g:361:7: builtInCall
 10870  456 
                     {
 10871  1088 
                     root_0 = (Object)adaptor.nil();
 10872   
 
 10873  456 
 
 10874  632 
                     pushFollow(FOLLOW_builtInCall_in_constraint2890);
 10875  1088 
                     builtInCall244=builtInCall();
 10876   
 
 10877  632 
                     state._fsp--;
 10878  456 
 
 10879  632 
                     adaptor.addChild(root_0, builtInCall244.getTree());
 10880   
 
 10881   
                     }
 10882  790 
                     break;
 10883   
                 case 3 :
 10884   
                     // com\\googlecode\\sparkleg\\Sparql.g:362:7: functionCall
 10885  158 
                     {
 10886  190 
                     root_0 = (Object)adaptor.nil();
 10887   
 
 10888  158 
 
 10889  32 
                     pushFollow(FOLLOW_functionCall_in_constraint2898);
 10890  190 
                     functionCall245=functionCall();
 10891   
 
 10892  32 
                     state._fsp--;
 10893  158 
 
 10894  32 
                     adaptor.addChild(root_0, functionCall245.getTree());
 10895   
 
 10896   
                     }
 10897  8 
                     break;
 10898   
 
 10899   
             }
 10900  2460 
             retval.stop = input.LT(-1);
 10901  8 
 
 10902   
 
 10903  2460 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10904  2452 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10905  8 
 
 10906   
         }
 10907  2 
         catch (RecognitionException re) {
 10908  2 
             reportError(re);
 10909  2 
             recover(input,re);
 10910  2 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10911  622 
 
 10912   
         }
 10913   
 
 10914  622 
         finally {
 10915  622 
                 // do for sure before leaving
 10916  2454 
         }
 10917  2454 
         return retval;
 10918  2 
     }
 10919  2 
     // $ANTLR end "constraint"
 10920  2 
 
 10921  2 
 
 10922  32 
     public static class functionCall_return extends ParserRuleReturnScope {
 10923   
         Object tree;
 10924  32 
         public Object getTree() { return tree; }
 10925   
     };
 10926   
 
 10927  624 
 
 10928  624 
     // $ANTLR start "functionCall"
 10929   
     // com\\googlecode\\sparkleg\\Sparql.g:365:1: functionCall : iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) ;
 10930   
     public final SparqlParser.functionCall_return functionCall() throws RecognitionException {
 10931  32 
         SparqlParser.functionCall_return retval = new SparqlParser.functionCall_return();
 10932  32 
         retval.start = input.LT(1);
 10933  8 
 
 10934   
 
 10935  32 
         Object root_0 = null;
 10936   
 
 10937  32 
         SparqlParser.iriRef_return iriRef246 =null;
 10938   
 
 10939  32 
         SparqlParser.argList_return argList247 =null;
 10940   
 
 10941   
 
 10942  40 
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 10943  40 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 10944   
         try {
 10945   
             // com\\googlecode\\sparkleg\\Sparql.g:366:5: ( iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) )
 10946  8 
             // com\\googlecode\\sparkleg\\Sparql.g:366:7: iriRef argList
 10947   
             {
 10948  40 
             pushFollow(FOLLOW_iriRef_in_functionCall2915);
 10949  32 
             iriRef246=iriRef();
 10950  8 
 
 10951  32 
             state._fsp--;
 10952   
 
 10953  40 
             stream_iriRef.add(iriRef246.getTree());
 10954  8 
 
 10955  32 
             pushFollow(FOLLOW_argList_in_functionCall2917);
 10956  32 
             argList247=argList();
 10957   
 
 10958  32 
             state._fsp--;
 10959  8 
 
 10960  40 
             stream_argList.add(argList247.getTree());
 10961   
 
 10962  8 
             // AST REWRITE
 10963   
             // elements: argList, iriRef
 10964  8 
             // token labels:
 10965   
             // rule labels: retval
 10966  8 
             // token list labels:
 10967  8 
             // rule list labels:
 10968   
             // wildcard labels:
 10969  40 
             retval.tree = root_0;
 10970  32 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10971  8 
 
 10972  32 
             root_0 = (Object)adaptor.nil();
 10973   
             // 366:22: -> ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10974   
             {
 10975   
                 // com\\googlecode\\sparkleg\\Sparql.g:366:25: ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10976   
                 {
 10977  32 
                 Object root_1 = (Object)adaptor.nil();
 10978  32 
                 root_1 = (Object)adaptor.becomeRoot(
 10979   
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 10980  8 
                 , root_1);
 10981  8 
 
 10982  32 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 10983  8 
 
 10984   
                 // com\\googlecode\\sparkleg\\Sparql.g:366:43: ^( ARG_LIST argList )
 10985   
                 {
 10986  32 
                 Object root_2 = (Object)adaptor.nil();
 10987  32 
                 root_2 = (Object)adaptor.becomeRoot(
 10988  8 
                 (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 10989  8 
                 , root_2);
 10990   
 
 10991  32 
                 adaptor.addChild(root_2, stream_argList.nextTree());
 10992   
 
 10993  40 
                 adaptor.addChild(root_1, root_2);
 10994   
                 }
 10995   
 
 10996  32 
                 adaptor.addChild(root_0, root_1);
 10997  8 
                 }
 10998  8 
 
 10999   
             }
 11000   
 
 11001   
 
 11002  40 
             retval.tree = root_0;
 11003   
 
 11004  8 
             }
 11005   
 
 11006  32 
             retval.stop = input.LT(-1);
 11007  8 
 
 11008   
 
 11009  32 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11010  32 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11011   
 
 11012   
         }
 11013  8 
         catch (RecognitionException re) {
 11014  0 
             reportError(re);
 11015  0 
             recover(input,re);
 11016  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11017  8 
 
 11018   
         }
 11019   
 
 11020  8 
         finally {
 11021  8 
                 // do for sure before leaving
 11022  32 
         }
 11023  32 
         return retval;
 11024   
     }
 11025   
     // $ANTLR end "functionCall"
 11026   
 
 11027   
 
 11028  416 
     public static class argList_return extends ParserRuleReturnScope {
 11029   
         Object tree;
 11030  416 
         public Object getTree() { return tree; }
 11031   
     };
 11032   
 
 11033  8 
 
 11034  8 
     // $ANTLR start "argList"
 11035   
     // com\\googlecode\\sparkleg\\Sparql.g:369:1: argList : ( nil -> nil | '(' ( DISTINCT )? expression ( ',' expression )* ')' -> ( DISTINCT )? ( expression )* );
 11036   
     public final SparqlParser.argList_return argList() throws RecognitionException {
 11037  416 
         SparqlParser.argList_return retval = new SparqlParser.argList_return();
 11038  416 
         retval.start = input.LT(1);
 11039  56 
 
 11040   
 
 11041  416 
         Object root_0 = null;
 11042   
 
 11043  416 
         Token char_literal249=null;
 11044  416 
         Token DISTINCT250=null;
 11045  416 
         Token char_literal252=null;
 11046  416 
         Token char_literal254=null;
 11047  416 
         SparqlParser.nil_return nil248 =null;
 11048  56 
 
 11049  472 
         SparqlParser.expression_return expression251 =null;
 11050   
 
 11051  416 
         SparqlParser.expression_return expression253 =null;
 11052  56 
 
 11053   
 
 11054  472 
         Object char_literal249_tree=null;
 11055  472 
         Object DISTINCT250_tree=null;
 11056  472 
         Object char_literal252_tree=null;
 11057  472 
         Object char_literal254_tree=null;
 11058  472 
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 11059  416 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 11060  472 
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 11061  416 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 11062  472 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 11063  416 
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 11064   
         try {
 11065  56 
             // com\\googlecode\\sparkleg\\Sparql.g:370:5: ( nil -> nil | '(' ( DISTINCT )? expression ( ',' expression )* ')' -> ( DISTINCT )? ( expression )* )
 11066  472 
             int alt80=2;
 11067  472 
             switch ( input.LA(1) ) {
 11068  56 
             case 209:
 11069  56 
                 {
 11070  472 
                 switch ( input.LA(2) ) {
 11071  56 
                 case 210:
 11072  56 
                     {
 11073  272 
                     alt80=1;
 11074  56 
                     }
 11075  216 
                     break;
 11076   
                 case ABS:
 11077  56 
                 case AVG:
 11078  56 
                 case BNODE:
 11079   
                 case BOUND:
 11080   
                 case CEIL:
 11081  56 
                 case COALESCE:
 11082   
                 case CONCAT:
 11083   
                 case CONTAINS:
 11084  6 
                 case COUNT:
 11085   
                 case DATATYPE:
 11086  6 
                 case DAY:
 11087   
                 case DECIMAL:
 11088   
                 case DECIMAL_NEGATIVE:
 11089   
                 case DECIMAL_POSITIVE:
 11090   
                 case DISTINCT:
 11091   
                 case DOUBLE:
 11092   
                 case DOUBLE_NEGATIVE:
 11093   
                 case DOUBLE_POSITIVE:
 11094   
                 case ENCODE_FOR_URI:
 11095   
                 case EXISTS:
 11096   
                 case FALSE:
 11097   
                 case FLOOR:
 11098   
                 case GROUP_CONCAT:
 11099   
                 case HOURS:
 11100   
                 case IF:
 11101   
                 case INTEGER:
 11102   
                 case INTEGER_NEGATIVE:
 11103   
                 case INTEGER_POSITIVE:
 11104   
                 case IRI:
 11105   
                 case IRI_REF:
 11106   
                 case ISBLANK:
 11107   
                 case ISIRI:
 11108   
                 case ISLITERAL:
 11109   
                 case ISNUMERIC:
 11110   
                 case ISURI:
 11111   
                 case LANG:
 11112   
                 case LANGMATCHES:
 11113   
                 case LCASE:
 11114   
                 case MAX:
 11115   
                 case MD5:
 11116   
                 case MIN:
 11117   
                 case MINUS:
 11118   
                 case MINUTES:
 11119   
                 case MONTH:
 11120   
                 case NEGATION:
 11121   
                 case NOT:
 11122   
                 case NOW:
 11123   
                 case PLUS:
 11124   
                 case PNAME_LN:
 11125   
                 case PNAME_NS:
 11126   
                 case RAND:
 11127   
                 case REGEX:
 11128   
                 case REPLACE:
 11129   
                 case ROUND:
 11130   
                 case SAMETERM:
 11131   
                 case SAMPLE:
 11132   
                 case SECONDS:
 11133   
                 case SHA1:
 11134   
                 case SHA256:
 11135   
                 case SHA384:
 11136   
                 case SHA512:
 11137   
                 case STR:
 11138   
                 case STRAFTER:
 11139   
                 case STRBEFORE:
 11140   
                 case STRDT:
 11141   
                 case STRENDS:
 11142   
                 case STRING_LITERAL1:
 11143   
                 case STRING_LITERAL2:
 11144   
                 case STRING_LITERAL_LONG1:
 11145   
                 case STRING_LITERAL_LONG2:
 11146   
                 case STRLANG:
 11147   
                 case STRLEN:
 11148   
                 case STRSTARTS:
 11149   
                 case SUBSTR:
 11150   
                 case SUM:
 11151   
                 case TIMEZONE:
 11152   
                 case TRUE:
 11153   
                 case TZ:
 11154   
                 case UCASE:
 11155   
                 case URI:
 11156   
                 case VAR1:
 11157   
                 case VAR2:
 11158   
                 case YEAR:
 11159   
                 case 209:
 11160   
                     {
 11161  200 
                     alt80=2;
 11162   
                     }
 11163  200 
                     break;
 11164   
                 default:
 11165  0 
                     NoViableAltException nvae =
 11166   
                         new NoViableAltException("", 80, 1, input);
 11167   
 
 11168  0 
                     throw nvae;
 11169   
 
 11170   
                 }
 11171   
 
 11172  50 
                 }
 11173  416 
                 break;
 11174  50 
             default:
 11175  0 
                 NoViableAltException nvae =
 11176   
                     new NoViableAltException("", 80, 0, input);
 11177   
 
 11178  0 
                 throw nvae;
 11179   
 
 11180   
             }
 11181   
 
 11182  416 
             switch (alt80) {
 11183   
                 case 1 :
 11184  56 
                     // com\\googlecode\\sparkleg\\Sparql.g:370:7: nil
 11185   
                     {
 11186  216 
                     pushFollow(FOLLOW_nil_in_argList2948);
 11187  216 
                     nil248=nil();
 11188   
 
 11189  216 
                     state._fsp--;
 11190   
 
 11191  216 
                     stream_nil.add(nil248.getTree());
 11192   
 
 11193  56 
                     // AST REWRITE
 11194   
                     // elements: nil
 11195   
                     // token labels:
 11196   
                     // rule labels: retval
 11197  6 
                     // token list labels:
 11198  6 
                     // rule list labels:
 11199   
                     // wildcard labels:
 11200  222 
                     retval.tree = root_0;
 11201  216 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11202  6 
 
 11203  216 
                     root_0 = (Object)adaptor.nil();
 11204   
                     // 370:11: -> nil
 11205   
                     {
 11206  216 
                         adaptor.addChild(root_0, stream_nil.nextTree());
 11207   
 
 11208   
                     }
 11209   
 
 11210   
 
 11211  222 
                     retval.tree = root_0;
 11212  6 
 
 11213   
                     }
 11214  222 
                     break;
 11215   
                 case 2 :
 11216   
                     // com\\googlecode\\sparkleg\\Sparql.g:371:7: '(' ( DISTINCT )? expression ( ',' expression )* ')'
 11217  6 
                     {
 11218  200 
                     char_literal249=(Token)match(input,209,FOLLOW_209_in_argList2960);
 11219  200 
                     stream_209.add(char_literal249);
 11220   
 
 11221   
 
 11222  6 
                     // com\\googlecode\\sparkleg\\Sparql.g:371:11: ( DISTINCT )?
 11223  200 
                     int alt78=2;
 11224  200 
                     switch ( input.LA(1) ) {
 11225  6 
                         case DISTINCT:
 11226   
                             {
 11227  0 
                             alt78=1;
 11228   
                             }
 11229  50 
                             break;
 11230  50 
                     }
 11231   
 
 11232  200 
                     switch (alt78) {
 11233   
                         case 1 :
 11234  50 
                             // com\\googlecode\\sparkleg\\Sparql.g:371:11: DISTINCT
 11235  50 
                             {
 11236  0 
                             DISTINCT250=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_argList2962);
 11237  0 
                             stream_DISTINCT.add(DISTINCT250);
 11238   
 
 11239   
 
 11240   
                             }
 11241   
                             break;
 11242   
 
 11243  50 
                     }
 11244   
 
 11245   
 
 11246  200 
                     pushFollow(FOLLOW_expression_in_argList2965);
 11247  200 
                     expression251=expression();
 11248   
 
 11249  200 
                     state._fsp--;
 11250   
 
 11251  200 
                     stream_expression.add(expression251.getTree());
 11252   
 
 11253   
                     // com\\googlecode\\sparkleg\\Sparql.g:371:32: ( ',' expression )*
 11254   
                     loop79:
 11255   
                     do {
 11256  272 
                         int alt79=2;
 11257  322 
                         switch ( input.LA(1) ) {
 11258  50 
                         case 211:
 11259   
                             {
 11260  122 
                             alt79=1;
 11261   
                             }
 11262  50 
                             break;
 11263   
 
 11264   
                         }
 11265   
 
 11266  272 
                         switch (alt79) {
 11267  68 
                             case 1 :
 11268  68 
                                 // com\\googlecode\\sparkleg\\Sparql.g:371:33: ',' expression
 11269   
                                 {
 11270  72 
                                 char_literal252=(Token)match(input,211,FOLLOW_211_in_argList2968);
 11271  90 
                                 stream_211.add(char_literal252);
 11272   
 
 11273   
 
 11274  72 
                                 pushFollow(FOLLOW_expression_in_argList2970);
 11275  72 
                                 expression253=expression();
 11276   
 
 11277  140 
                                 state._fsp--;
 11278   
 
 11279  72 
                                 stream_expression.add(expression253.getTree());
 11280   
 
 11281  18 
                                 }
 11282  90 
                                 break;
 11283   
 
 11284   
                             default :
 11285  218 
                                 break loop79;
 11286  18 
                         }
 11287  72 
                     } while (true);
 11288  18 
 
 11289   
 
 11290  218 
                     char_literal254=(Token)match(input,210,FOLLOW_210_in_argList2974);
 11291  200 
                     stream_210.add(char_literal254);
 11292   
 
 11293  18 
 
 11294   
                     // AST REWRITE
 11295   
                     // elements: DISTINCT, expression
 11296  50 
                     // token labels:
 11297   
                     // rule labels: retval
 11298  18 
                     // token list labels:
 11299   
                     // rule list labels:
 11300   
                     // wildcard labels:
 11301  250 
                     retval.tree = root_0;
 11302  250 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11303   
 
 11304  200 
                     root_0 = (Object)adaptor.nil();
 11305   
                     // 371:54: -> ( DISTINCT )? ( expression )*
 11306   
                     {
 11307   
                         // com\\googlecode\\sparkleg\\Sparql.g:371:57: ( DISTINCT )?
 11308  200 
                         if ( stream_DISTINCT.hasNext() ) {
 11309  0 
                             adaptor.addChild(root_0,
 11310   
                             stream_DISTINCT.nextNode()
 11311   
                             );
 11312  50 
 
 11313  50 
                         }
 11314  200 
                         stream_DISTINCT.reset();
 11315  50 
 
 11316   
                         // com\\googlecode\\sparkleg\\Sparql.g:371:67: ( expression )*
 11317  472 
                         while ( stream_expression.hasNext() ) {
 11318  272 
                             adaptor.addChild(root_0, stream_expression.nextTree());
 11319  50 
 
 11320   
                         }
 11321  200 
                         stream_expression.reset();
 11322   
 
 11323   
                     }
 11324   
 
 11325  50 
 
 11326  200 
                     retval.tree = root_0;
 11327   
 
 11328  118 
                     }
 11329  68 
                     break;
 11330   
 
 11331   
             }
 11332  466 
             retval.stop = input.LT(-1);
 11333   
 
 11334   
 
 11335  416 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11336  416 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11337  50 
 
 11338   
         }
 11339  0 
         catch (RecognitionException re) {
 11340  0 
             reportError(re);
 11341  0 
             recover(input,re);
 11342  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11343  56 
 
 11344   
         }
 11345   
 
 11346  56 
         finally {
 11347  56 
                 // do for sure before leaving
 11348  416 
         }
 11349  416 
         return retval;
 11350   
     }
 11351   
     // $ANTLR end "argList"
 11352   
 
 11353   
 
 11354  120 
     public static class expressionList_return extends ParserRuleReturnScope {
 11355   
         Object tree;
 11356  120 
         public Object getTree() { return tree; }
 11357   
     };
 11358   
 
 11359  56 
 
 11360  56 
     // $ANTLR start "expressionList"
 11361   
     // com\\googlecode\\sparkleg\\Sparql.g:374:1: expressionList : ( nil | '(' expression ( ',' expression )* ')' ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) ;
 11362   
     public final SparqlParser.expressionList_return expressionList() throws RecognitionException {
 11363  120 
         SparqlParser.expressionList_return retval = new SparqlParser.expressionList_return();
 11364  120 
         retval.start = input.LT(1);
 11365  30 
 
 11366   
 
 11367  120 
         Object root_0 = null;
 11368   
 
 11369  120 
         Token char_literal256=null;
 11370  120 
         Token char_literal258=null;
 11371  120 
         Token char_literal260=null;
 11372  120 
         SparqlParser.nil_return nil255 =null;
 11373   
 
 11374  150 
         SparqlParser.expression_return expression257 =null;
 11375  30 
 
 11376  120 
         SparqlParser.expression_return expression259 =null;
 11377   
 
 11378  30 
 
 11379  120 
         Object char_literal256_tree=null;
 11380  150 
         Object char_literal258_tree=null;
 11381  150 
         Object char_literal260_tree=null;
 11382  150 
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 11383  150 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 11384  120 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 11385  150 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 11386  120 
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 11387  30 
         try {
 11388   
             // com\\googlecode\\sparkleg\\Sparql.g:375:5: ( ( nil | '(' expression ( ',' expression )* ')' ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) )
 11389   
             // com\\googlecode\\sparkleg\\Sparql.g:375:7: ( nil | '(' expression ( ',' expression )* ')' )
 11390  30 
             {
 11391  30 
             // com\\googlecode\\sparkleg\\Sparql.g:375:7: ( nil | '(' expression ( ',' expression )* ')' )
 11392  150 
             int alt82=2;
 11393  150 
             switch ( input.LA(1) ) {
 11394  30 
             case 209:
 11395  30 
                 {
 11396  150 
                 switch ( input.LA(2) ) {
 11397  30 
                 case 210:
 11398   
                     {
 11399  8 
                     alt82=1;
 11400   
                     }
 11401  8 
                     break;
 11402   
                 case ABS:
 11403  30 
                 case AVG:
 11404  30 
                 case BNODE:
 11405   
                 case BOUND:
 11406   
                 case CEIL:
 11407  30 
                 case COALESCE:
 11408   
                 case CONCAT:
 11409   
                 case CONTAINS:
 11410  2 
                 case COUNT:
 11411   
                 case DATATYPE:
 11412  2 
                 case DAY:
 11413   
                 case DECIMAL:
 11414   
                 case DECIMAL_NEGATIVE:
 11415   
                 case DECIMAL_POSITIVE:
 11416   
                 case DOUBLE:
 11417   
                 case DOUBLE_NEGATIVE:
 11418   
                 case DOUBLE_POSITIVE:
 11419   
                 case ENCODE_FOR_URI:
 11420   
                 case EXISTS:
 11421   
                 case FALSE:
 11422   
                 case FLOOR:
 11423   
                 case GROUP_CONCAT:
 11424   
                 case HOURS:
 11425   
                 case IF:
 11426   
                 case INTEGER:
 11427   
                 case INTEGER_NEGATIVE:
 11428   
                 case INTEGER_POSITIVE:
 11429   
                 case IRI:
 11430   
                 case IRI_REF:
 11431   
                 case ISBLANK:
 11432   
                 case ISIRI:
 11433   
                 case ISLITERAL:
 11434   
                 case ISNUMERIC:
 11435   
                 case ISURI:
 11436   
                 case LANG:
 11437   
                 case LANGMATCHES:
 11438   
                 case LCASE:
 11439   
                 case MAX:
 11440   
                 case MD5:
 11441   
                 case MIN:
 11442   
                 case MINUS:
 11443   
                 case MINUTES:
 11444   
                 case MONTH:
 11445   
                 case NEGATION:
 11446   
                 case NOT:
 11447   
                 case NOW:
 11448   
                 case PLUS:
 11449   
                 case PNAME_LN:
 11450   
                 case PNAME_NS:
 11451   
                 case RAND:
 11452   
                 case REGEX:
 11453   
                 case REPLACE:
 11454   
                 case ROUND:
 11455   
                 case SAMETERM:
 11456   
                 case SAMPLE:
 11457   
                 case SECONDS:
 11458   
                 case SHA1:
 11459   
                 case SHA256:
 11460   
                 case SHA384:
 11461   
                 case SHA512:
 11462   
                 case STR:
 11463   
                 case STRAFTER:
 11464   
                 case STRBEFORE:
 11465   
                 case STRDT:
 11466   
                 case STRENDS:
 11467   
                 case STRING_LITERAL1:
 11468   
                 case STRING_LITERAL2:
 11469   
                 case STRING_LITERAL_LONG1:
 11470   
                 case STRING_LITERAL_LONG2:
 11471   
                 case STRLANG:
 11472   
                 case STRLEN:
 11473   
                 case STRSTARTS:
 11474   
                 case SUBSTR:
 11475   
                 case SUM:
 11476   
                 case TIMEZONE:
 11477   
                 case TRUE:
 11478   
                 case TZ:
 11479   
                 case UCASE:
 11480   
                 case URI:
 11481   
                 case VAR1:
 11482   
                 case VAR2:
 11483   
                 case YEAR:
 11484   
                 case 209:
 11485   
                     {
 11486  112 
                     alt82=2;
 11487   
                     }
 11488  112 
                     break;
 11489   
                 default:
 11490  0 
                     NoViableAltException nvae =
 11491   
                         new NoViableAltException("", 82, 1, input);
 11492   
 
 11493  0 
                     throw nvae;
 11494   
 
 11495   
                 }
 11496   
 
 11497  28 
                 }
 11498  120 
                 break;
 11499  28 
             default:
 11500  0 
                 NoViableAltException nvae =
 11501   
                     new NoViableAltException("", 82, 0, input);
 11502   
 
 11503  0 
                 throw nvae;
 11504   
 
 11505   
             }
 11506   
 
 11507  120 
             switch (alt82) {
 11508   
                 case 1 :
 11509  30 
                     // com\\googlecode\\sparkleg\\Sparql.g:375:8: nil
 11510   
                     {
 11511  8 
                     pushFollow(FOLLOW_nil_in_expressionList3000);
 11512  8 
                     nil255=nil();
 11513   
 
 11514  8 
                     state._fsp--;
 11515   
 
 11516  8 
                     stream_nil.add(nil255.getTree());
 11517   
 
 11518  30 
                     }
 11519  8 
                     break;
 11520   
                 case 2 :
 11521   
                     // com\\googlecode\\sparkleg\\Sparql.g:375:14: '(' expression ( ',' expression )* ')'
 11522  2 
                     {
 11523  114 
                     char_literal256=(Token)match(input,209,FOLLOW_209_in_expressionList3004);
 11524  112 
                     stream_209.add(char_literal256);
 11525  2 
 
 11526   
 
 11527  114 
                     pushFollow(FOLLOW_expression_in_expressionList3006);
 11528  112 
                     expression257=expression();
 11529   
 
 11530  114 
                     state._fsp--;
 11531   
 
 11532  112 
                     stream_expression.add(expression257.getTree());
 11533   
 
 11534  28 
                     // com\\googlecode\\sparkleg\\Sparql.g:375:29: ( ',' expression )*
 11535  28 
                     loop81:
 11536   
                     do {
 11537  248 
                         int alt81=2;
 11538  276 
                         switch ( input.LA(1) ) {
 11539  28 
                         case 211:
 11540   
                             {
 11541  164 
                             alt81=1;
 11542   
                             }
 11543  28 
                             break;
 11544   
 
 11545   
                         }
 11546   
 
 11547  248 
                         switch (alt81) {
 11548  62 
                             case 1 :
 11549  62 
                                 // com\\googlecode\\sparkleg\\Sparql.g:375:30: ',' expression
 11550   
                                 {
 11551  136 
                                 char_literal258=(Token)match(input,211,FOLLOW_211_in_expressionList3009);
 11552  170 
                                 stream_211.add(char_literal258);
 11553   
 
 11554   
 
 11555  136 
                                 pushFollow(FOLLOW_expression_in_expressionList3011);
 11556  136 
                                 expression259=expression();
 11557   
 
 11558  198 
                                 state._fsp--;
 11559   
 
 11560  136 
                                 stream_expression.add(expression259.getTree());
 11561   
 
 11562  34 
                                 }
 11563  170 
                                 break;
 11564   
 
 11565   
                             default :
 11566  146 
                                 break loop81;
 11567  34 
                         }
 11568  136 
                     } while (true);
 11569  34 
 
 11570   
 
 11571  146 
                     char_literal260=(Token)match(input,210,FOLLOW_210_in_expressionList3015);
 11572  112 
                     stream_210.add(char_literal260);
 11573   
 
 11574  34 
 
 11575   
                     }
 11576   
                     break;
 11577  28 
 
 11578   
             }
 11579  34 
 
 11580   
 
 11581   
             // AST REWRITE
 11582  28 
             // elements: expression, nil
 11583  28 
             // token labels:
 11584   
             // rule labels: retval
 11585   
             // token list labels:
 11586   
             // rule list labels:
 11587   
             // wildcard labels:
 11588  120 
             retval.tree = root_0;
 11589  120 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11590   
 
 11591  120 
             root_0 = (Object)adaptor.nil();
 11592   
             // 375:52: -> ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11593   
             {
 11594   
                 // com\\googlecode\\sparkleg\\Sparql.g:375:55: ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11595   
                 {
 11596  120 
                 Object root_1 = (Object)adaptor.nil();
 11597  120 
                 root_1 = (Object)adaptor.becomeRoot(
 11598   
                 (Object)adaptor.create(EXPRESSION_LIST, "EXPRESSION_LIST")
 11599  30 
                 , root_1);
 11600  30 
 
 11601   
                 // com\\googlecode\\sparkleg\\Sparql.g:375:73: ( nil )*
 11602  158 
                 while ( stream_nil.hasNext() ) {
 11603  8 
                     adaptor.addChild(root_1, stream_nil.nextTree());
 11604   
 
 11605   
                 }
 11606  120 
                 stream_nil.reset();
 11607  30 
 
 11608  30 
                 // com\\googlecode\\sparkleg\\Sparql.g:375:78: ( expression )*
 11609  368 
                 while ( stream_expression.hasNext() ) {
 11610  248 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 11611   
 
 11612   
                 }
 11613  152 
                 stream_expression.reset();
 11614  2 
 
 11615  120 
                 adaptor.addChild(root_0, root_1);
 11616   
                 }
 11617  30 
 
 11618   
             }
 11619   
 
 11620  92 
 
 11621  182 
             retval.tree = root_0;
 11622   
 
 11623   
             }
 11624  30 
 
 11625  120 
             retval.stop = input.LT(-1);
 11626  30 
 
 11627   
 
 11628  120 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11629  120 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11630   
 
 11631   
         }
 11632  30 
         catch (RecognitionException re) {
 11633  0 
             reportError(re);
 11634  0 
             recover(input,re);
 11635  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11636  30 
 
 11637   
         }
 11638   
 
 11639  30 
         finally {
 11640  30 
                 // do for sure before leaving
 11641  120 
         }
 11642  120 
         return retval;
 11643   
     }
 11644   
     // $ANTLR end "expressionList"
 11645   
 
 11646   
 
 11647  216 
     public static class constructTemplate_return extends ParserRuleReturnScope {
 11648   
         Object tree;
 11649  216 
         public Object getTree() { return tree; }
 11650   
     };
 11651   
 
 11652  30 
 
 11653  30 
     // $ANTLR start "constructTemplate"
 11654   
     // com\\googlecode\\sparkleg\\Sparql.g:378:1: constructTemplate : '{' ( constructTriples )? '}' -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) ;
 11655   
     public final SparqlParser.constructTemplate_return constructTemplate() throws RecognitionException {
 11656  216 
         SparqlParser.constructTemplate_return retval = new SparqlParser.constructTemplate_return();
 11657  216 
         retval.start = input.LT(1);
 11658  54 
 
 11659   
 
 11660  216 
         Object root_0 = null;
 11661   
 
 11662  216 
         Token char_literal261=null;
 11663  216 
         Token char_literal263=null;
 11664  216 
         SparqlParser.constructTriples_return constructTriples262 =null;
 11665   
 
 11666   
 
 11667  270 
         Object char_literal261_tree=null;
 11668  270 
         Object char_literal263_tree=null;
 11669  216 
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 11670  216 
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 11671  270 
         RewriteRuleSubtreeStream stream_constructTriples=new RewriteRuleSubtreeStream(adaptor,"rule constructTriples");
 11672   
         try {
 11673  54 
             // com\\googlecode\\sparkleg\\Sparql.g:379:5: ( '{' ( constructTriples )? '}' -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) )
 11674  54 
             // com\\googlecode\\sparkleg\\Sparql.g:379:7: '{' ( constructTriples )? '}'
 11675  54 
             {
 11676  216 
             char_literal261=(Token)match(input,216,FOLLOW_216_in_constructTemplate3046);
 11677  216 
             stream_216.add(char_literal261);
 11678  54 
 
 11679  54 
 
 11680  54 
             // com\\googlecode\\sparkleg\\Sparql.g:379:11: ( constructTriples )?
 11681  270 
             int alt83=2;
 11682  270 
             switch ( input.LA(1) ) {
 11683   
                 case BLANK_NODE_LABEL:
 11684   
                 case DECIMAL:
 11685   
                 case DECIMAL_NEGATIVE:
 11686   
                 case DECIMAL_POSITIVE:
 11687  54 
                 case DOUBLE:
 11688  54 
                 case DOUBLE_NEGATIVE:
 11689   
                 case DOUBLE_POSITIVE:
 11690   
                 case FALSE:
 11691   
                 case INTEGER:
 11692  54 
                 case INTEGER_NEGATIVE:
 11693  54 
                 case INTEGER_POSITIVE:
 11694   
                 case IRI_REF:
 11695   
                 case PNAME_LN:
 11696   
                 case PNAME_NS:
 11697   
                 case STRING_LITERAL1:
 11698   
                 case STRING_LITERAL2:
 11699   
                 case STRING_LITERAL_LONG1:
 11700   
                 case STRING_LITERAL_LONG2:
 11701   
                 case TRUE:
 11702   
                 case VAR1:
 11703   
                 case VAR2:
 11704   
                 case 209:
 11705   
                 case 213:
 11706   
                     {
 11707  208 
                     alt83=1;
 11708   
                     }
 11709   
                     break;
 11710   
             }
 11711   
 
 11712  216 
             switch (alt83) {
 11713   
                 case 1 :
 11714   
                     // com\\googlecode\\sparkleg\\Sparql.g:379:11: constructTriples
 11715   
                     {
 11716  208 
                     pushFollow(FOLLOW_constructTriples_in_constructTemplate3048);
 11717  208 
                     constructTriples262=constructTriples();
 11718  52 
 
 11719  208 
                     state._fsp--;
 11720   
 
 11721  208 
                     stream_constructTriples.add(constructTriples262.getTree());
 11722   
 
 11723  54 
                     }
 11724   
                     break;
 11725   
 
 11726   
             }
 11727  52 
 
 11728  52 
 
 11729  216 
             char_literal263=(Token)match(input,218,FOLLOW_218_in_constructTemplate3051);
 11730  268 
             stream_218.add(char_literal263);
 11731   
 
 11732  52 
 
 11733   
             // AST REWRITE
 11734   
             // elements: constructTriples
 11735   
             // token labels:
 11736   
             // rule labels: retval
 11737   
             // token list labels:
 11738   
             // rule list labels:
 11739   
             // wildcard labels:
 11740  270 
             retval.tree = root_0;
 11741  270 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11742   
 
 11743  216 
             root_0 = (Object)adaptor.nil();
 11744   
             // 379:33: -> ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11745   
             {
 11746   
                 // com\\googlecode\\sparkleg\\Sparql.g:379:36: ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11747   
                 {
 11748  216 
                 Object root_1 = (Object)adaptor.nil();
 11749  216 
                 root_1 = (Object)adaptor.becomeRoot(
 11750   
                 (Object)adaptor.create(CONSTRUCT_TRIPLES, "CONSTRUCT_TRIPLES")
 11751  54 
                 , root_1);
 11752  54 
 
 11753   
                 // com\\googlecode\\sparkleg\\Sparql.g:379:56: ( constructTriples )?
 11754  270 
                 if ( stream_constructTriples.hasNext() ) {
 11755  208 
                     adaptor.addChild(root_1, stream_constructTriples.nextTree());
 11756   
 
 11757   
                 }
 11758  216 
                 stream_constructTriples.reset();
 11759  54 
 
 11760  270 
                 adaptor.addChild(root_0, root_1);
 11761   
                 }
 11762   
 
 11763   
             }
 11764   
 
 11765  54 
 
 11766  268 
             retval.tree = root_0;
 11767   
 
 11768   
             }
 11769  54 
 
 11770  216 
             retval.stop = input.LT(-1);
 11771  54 
 
 11772   
 
 11773  216 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11774  216 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11775   
 
 11776   
         }
 11777  54 
         catch (RecognitionException re) {
 11778  0 
             reportError(re);
 11779  0 
             recover(input,re);
 11780  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11781  54 
 
 11782   
         }
 11783   
 
 11784  54 
         finally {
 11785  54 
                 // do for sure before leaving
 11786  216 
         }
 11787  216 
         return retval;
 11788   
     }
 11789   
     // $ANTLR end "constructTemplate"
 11790   
 
 11791   
 
 11792  208 
     public static class constructTriples_return extends ParserRuleReturnScope {
 11793   
         Object tree;
 11794  208 
         public Object getTree() { return tree; }
 11795   
     };
 11796   
 
 11797  54 
 
 11798  54 
     // $ANTLR start "constructTriples"
 11799   
     // com\\googlecode\\sparkleg\\Sparql.g:382:1: constructTriples : triplesSameSubject ( '.' triplesSameSubject )* ( '.' )? -> ( triplesSameSubject )+ ;
 11800   
     public final SparqlParser.constructTriples_return constructTriples() throws RecognitionException {
 11801  208 
         SparqlParser.constructTriples_return retval = new SparqlParser.constructTriples_return();
 11802  208 
         retval.start = input.LT(1);
 11803  52 
 
 11804   
 
 11805  208 
         Object root_0 = null;
 11806   
 
 11807  208 
         Token char_literal265=null;
 11808  208 
         Token char_literal267=null;
 11809  208 
         SparqlParser.triplesSameSubject_return triplesSameSubject264 =null;
 11810   
 
 11811  208 
         SparqlParser.triplesSameSubject_return triplesSameSubject266 =null;
 11812  52 
 
 11813  52 
 
 11814  208 
         Object char_literal265_tree=null;
 11815  208 
         Object char_literal267_tree=null;
 11816  260 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 11817  208 
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 11818  52 
         try {
 11819  52 
             // com\\googlecode\\sparkleg\\Sparql.g:383:5: ( triplesSameSubject ( '.' triplesSameSubject )* ( '.' )? -> ( triplesSameSubject )+ )
 11820  52 
             // com\\googlecode\\sparkleg\\Sparql.g:383:7: triplesSameSubject ( '.' triplesSameSubject )* ( '.' )?
 11821   
             {
 11822  260 
             pushFollow(FOLLOW_triplesSameSubject_in_constructTriples3077);
 11823  208 
             triplesSameSubject264=triplesSameSubject();
 11824   
 
 11825  260 
             state._fsp--;
 11826  52 
 
 11827  260 
             stream_triplesSameSubject.add(triplesSameSubject264.getTree());
 11828  52 
 
 11829   
             // com\\googlecode\\sparkleg\\Sparql.g:383:26: ( '.' triplesSameSubject )*
 11830   
             loop84:
 11831   
             do {
 11832  272 
                 int alt84=2;
 11833  324 
                 switch ( input.LA(1) ) {
 11834  52 
                 case DOT:
 11835   
                     {
 11836  226 
                     switch ( input.LA(2) ) {
 11837   
                     case BLANK_NODE_LABEL:
 11838  52 
                     case DECIMAL:
 11839   
                     case DECIMAL_NEGATIVE:
 11840   
                     case DECIMAL_POSITIVE:
 11841   
                     case DOUBLE:
 11842   
                     case DOUBLE_NEGATIVE:
 11843  68 
                     case DOUBLE_POSITIVE:
 11844  68 
                     case FALSE:
 11845   
                     case INTEGER:
 11846   
                     case INTEGER_NEGATIVE:
 11847  30 
                     case INTEGER_POSITIVE:
 11848   
                     case IRI_REF:
 11849   
                     case PNAME_LN:
 11850   
                     case PNAME_NS:
 11851   
                     case STRING_LITERAL1:
 11852   
                     case STRING_LITERAL2:
 11853   
                     case STRING_LITERAL_LONG1:
 11854   
                     case STRING_LITERAL_LONG2:
 11855   
                     case TRUE:
 11856   
                     case VAR1:
 11857   
                     case VAR2:
 11858   
                     case 209:
 11859   
                     case 213:
 11860   
                         {
 11861  64 
                         alt84=1;
 11862   
                         }
 11863   
                         break;
 11864   
 
 11865   
                     }
 11866   
 
 11867   
                     }
 11868   
                     break;
 11869   
 
 11870   
                 }
 11871   
 
 11872  288 
                 switch (alt84) {
 11873   
                     case 1 :
 11874   
                         // com\\googlecode\\sparkleg\\Sparql.g:383:27: '.' triplesSameSubject
 11875   
                         {
 11876  64 
                         char_literal265=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples3080);
 11877  64 
                         stream_DOT.add(char_literal265);
 11878   
 
 11879   
 
 11880  64 
                         pushFollow(FOLLOW_triplesSameSubject_in_constructTriples3082);
 11881  64 
                         triplesSameSubject266=triplesSameSubject();
 11882   
 
 11883  132 
                         state._fsp--;
 11884   
 
 11885  64 
                         stream_triplesSameSubject.add(triplesSameSubject266.getTree());
 11886   
 
 11887  16 
                         }
 11888  80 
                         break;
 11889   
 
 11890   
                     default :
 11891  224 
                         break loop84;
 11892  16 
                 }
 11893  64 
             } while (true);
 11894  16 
 
 11895   
 
 11896  16 
             // com\\googlecode\\sparkleg\\Sparql.g:383:52: ( '.' )?
 11897  208 
             int alt85=2;
 11898  208 
             switch ( input.LA(1) ) {
 11899  16 
                 case DOT:
 11900   
                     {
 11901  110 
                     alt85=1;
 11902  52 
                     }
 11903   
                     break;
 11904  16 
             }
 11905   
 
 11906  208 
             switch (alt85) {
 11907   
                 case 1 :
 11908  52 
                     // com\\googlecode\\sparkleg\\Sparql.g:383:52: '.'
 11909  52 
                     {
 11910  110 
                     char_literal267=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples3086);
 11911  110 
                     stream_DOT.add(char_literal267);
 11912  14 
 
 11913   
 
 11914   
                     }
 11915   
                     break;
 11916   
 
 11917  52 
             }
 11918   
 
 11919   
 
 11920   
             // AST REWRITE
 11921  14 
             // elements: triplesSameSubject
 11922  14 
             // token labels:
 11923   
             // rule labels: retval
 11924   
             // token list labels:
 11925   
             // rule list labels:
 11926   
             // wildcard labels:
 11927  208 
             retval.tree = root_0;
 11928  208 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11929   
 
 11930  208 
             root_0 = (Object)adaptor.nil();
 11931   
             // 383:57: -> ( triplesSameSubject )+
 11932   
             {
 11933  208 
                 if ( !(stream_triplesSameSubject.hasNext()) ) {
 11934  0 
                     throw new RewriteEarlyExitException();
 11935   
                 }
 11936  480 
                 while ( stream_triplesSameSubject.hasNext() ) {
 11937  272 
                     adaptor.addChild(root_0, stream_triplesSameSubject.nextTree());
 11938  52 
 
 11939  52 
                 }
 11940  208 
                 stream_triplesSameSubject.reset();
 11941  52 
 
 11942   
             }
 11943   
 
 11944  52 
 
 11945  208 
             retval.tree = root_0;
 11946   
 
 11947  120 
             }
 11948  68 
 
 11949  208 
             retval.stop = input.LT(-1);
 11950   
 
 11951  52 
 
 11952  208 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11953  208 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11954   
 
 11955   
         }
 11956  52 
         catch (RecognitionException re) {
 11957  0 
             reportError(re);
 11958  0 
             recover(input,re);
 11959  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11960  52 
 
 11961   
         }
 11962   
 
 11963  52 
         finally {
 11964  52 
                 // do for sure before leaving
 11965  208 
         }
 11966  208 
         return retval;
 11967   
     }
 11968   
     // $ANTLR end "constructTriples"
 11969   
 
 11970   
 
 11971  834 
     public static class triplesSameSubject_return extends ParserRuleReturnScope {
 11972   
         Object tree;
 11973  834 
         public Object getTree() { return tree; }
 11974   
     };
 11975   
 
 11976  52 
 
 11977  52 
     // $ANTLR start "triplesSameSubject"
 11978   
     // com\\googlecode\\sparkleg\\Sparql.g:386:1: triplesSameSubject : ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 11979   
     public final SparqlParser.triplesSameSubject_return triplesSameSubject() throws RecognitionException {
 11980  834 
         SparqlParser.triplesSameSubject_return retval = new SparqlParser.triplesSameSubject_return();
 11981  834 
         retval.start = input.LT(1);
 11982  210 
 
 11983   
 
 11984  210 
         Object root_0 = null;
 11985   
 
 11986  834 
         SparqlParser.varOrTerm_return varOrTerm268 =null;
 11987   
 
 11988  834 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty269 =null;
 11989   
 
 11990  834 
         SparqlParser.triplesNode_return triplesNode270 =null;
 11991  210 
 
 11992  1044 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty271 =null;
 11993   
 
 11994   
 
 11995  1044 
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 11996  834 
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 11997  1044 
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 11998   
         try {
 11999  210 
             // com\\googlecode\\sparkleg\\Sparql.g:387:5: ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 12000  834 
             int alt88=2;
 12001  1044 
             switch ( input.LA(1) ) {
 12002   
             case BLANK_NODE_LABEL:
 12003  210 
             case DECIMAL:
 12004   
             case DECIMAL_NEGATIVE:
 12005   
             case DECIMAL_POSITIVE:
 12006  210 
             case DOUBLE:
 12007  210 
             case DOUBLE_NEGATIVE:
 12008  210 
             case DOUBLE_POSITIVE:
 12009   
             case FALSE:
 12010   
             case INTEGER:
 12011  210 
             case INTEGER_NEGATIVE:
 12012  210 
             case INTEGER_POSITIVE:
 12013   
             case IRI_REF:
 12014   
             case PNAME_LN:
 12015   
             case PNAME_NS:
 12016   
             case STRING_LITERAL1:
 12017   
             case STRING_LITERAL2:
 12018   
             case STRING_LITERAL_LONG1:
 12019   
             case STRING_LITERAL_LONG2:
 12020   
             case TRUE:
 12021   
             case VAR1:
 12022   
             case VAR2:
 12023   
                 {
 12024  786 
                 alt88=1;
 12025   
                 }
 12026  786 
                 break;
 12027   
             case 213:
 12028   
                 {
 12029  48 
                 switch ( input.LA(2) ) {
 12030   
                 case 214:
 12031   
                     {
 12032  40 
                     alt88=1;
 12033   
                     }
 12034  40 
                     break;
 12035  198 
                 case A:
 12036   
                 case INVERSE:
 12037  198 
                 case IRI_REF:
 12038   
                 case NEGATION:
 12039   
                 case PNAME_LN:
 12040  12 
                 case PNAME_NS:
 12041   
                 case VAR1:
 12042   
                 case VAR2:
 12043  10 
                 case 209:
 12044   
                     {
 12045  18 
                     alt88=2;
 12046   
                     }
 12047  8 
                     break;
 12048   
                 default:
 12049  0 
                     NoViableAltException nvae =
 12050   
                         new NoViableAltException("", 88, 2, input);
 12051   
 
 12052  0 
                     throw nvae;
 12053   
 
 12054   
                 }
 12055   
 
 12056  2 
                 }
 12057  48 
                 break;
 12058  2 
             case 209:
 12059   
                 {
 12060  0 
                 switch ( input.LA(2) ) {
 12061   
                 case 210:
 12062   
                     {
 12063  0 
                     alt88=1;
 12064   
                     }
 12065  0 
                     break;
 12066   
                 case BLANK_NODE_LABEL:
 12067   
                 case DECIMAL:
 12068  12 
                 case DECIMAL_NEGATIVE:
 12069   
                 case DECIMAL_POSITIVE:
 12070   
                 case DOUBLE:
 12071   
                 case DOUBLE_NEGATIVE:
 12072   
                 case DOUBLE_POSITIVE:
 12073   
                 case FALSE:
 12074   
                 case INTEGER:
 12075   
                 case INTEGER_NEGATIVE:
 12076   
                 case INTEGER_POSITIVE:
 12077   
                 case IRI_REF:
 12078   
                 case PNAME_LN:
 12079   
                 case PNAME_NS:
 12080   
                 case STRING_LITERAL1:
 12081   
                 case STRING_LITERAL2:
 12082   
                 case STRING_LITERAL_LONG1:
 12083   
                 case STRING_LITERAL_LONG2:
 12084   
                 case TRUE:
 12085   
                 case VAR1:
 12086   
                 case VAR2:
 12087   
                 case 209:
 12088   
                 case 213:
 12089   
                     {
 12090  0 
                     alt88=2;
 12091   
                     }
 12092  0 
                     break;
 12093   
                 default:
 12094  0 
                     NoViableAltException nvae =
 12095   
                         new NoViableAltException("", 88, 3, input);
 12096   
 
 12097  0 
                     throw nvae;
 12098   
 
 12099   
                 }
 12100   
 
 12101   
                 }
 12102  0 
                 break;
 12103   
             default:
 12104  0 
                 NoViableAltException nvae =
 12105   
                     new NoViableAltException("", 88, 0, input);
 12106   
 
 12107  0 
                 throw nvae;
 12108   
 
 12109   
             }
 12110   
 
 12111  834 
             switch (alt88) {
 12112   
                 case 1 :
 12113   
                     // com\\googlecode\\sparkleg\\Sparql.g:387:7: varOrTerm ( propertyListNotEmpty )?
 12114   
                     {
 12115  826 
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubject3109);
 12116  826 
                     varOrTerm268=varOrTerm();
 12117   
 
 12118  826 
                     state._fsp--;
 12119   
 
 12120  826 
                     stream_varOrTerm.add(varOrTerm268.getTree());
 12121   
 
 12122  210 
                     // com\\googlecode\\sparkleg\\Sparql.g:387:17: ( propertyListNotEmpty )?
 12123  826 
                     int alt86=2;
 12124  826 
                     switch ( input.LA(1) ) {
 12125   
                         case A:
 12126  208 
                         case INVERSE:
 12127  208 
                         case IRI_REF:
 12128   
                         case NEGATION:
 12129  208 
                         case PNAME_LN:
 12130   
                         case PNAME_NS:
 12131  208 
                         case VAR1:
 12132   
                         case VAR2:
 12133  208 
                         case 209:
 12134  208 
                             {
 12135  826 
                             alt86=1;
 12136  208 
                             }
 12137   
                             break;
 12138  208 
                     }
 12139   
 
 12140  826 
                     switch (alt86) {
 12141   
                         case 1 :
 12142   
                             // com\\googlecode\\sparkleg\\Sparql.g:387:17: propertyListNotEmpty
 12143   
                             {
 12144  826 
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject3111);
 12145  826 
                             propertyListNotEmpty269=propertyListNotEmpty();
 12146   
 
 12147  1034 
                             state._fsp--;
 12148  208 
 
 12149  826 
                             stream_propertyListNotEmpty.add(propertyListNotEmpty269.getTree());
 12150  208 
 
 12151   
                             }
 12152   
                             break;
 12153   
 
 12154   
                     }
 12155  208 
 
 12156  208 
 
 12157   
                     // AST REWRITE
 12158   
                     // elements: propertyListNotEmpty, varOrTerm
 12159   
                     // token labels:
 12160   
                     // rule labels: retval
 12161   
                     // token list labels:
 12162  208 
                     // rule list labels:
 12163  208 
                     // wildcard labels:
 12164  826 
                     retval.tree = root_0;
 12165  826 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12166   
 
 12167  1034 
                     root_0 = (Object)adaptor.nil();
 12168   
                     // 387:39: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 12169  208 
                     {
 12170   
                         // com\\googlecode\\sparkleg\\Sparql.g:387:42: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 12171   
                         {
 12172  1034 
                         Object root_1 = (Object)adaptor.nil();
 12173  826 
                         root_1 = (Object)adaptor.becomeRoot(
 12174  208 
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12175   
                         , root_1);
 12176   
 
 12177   
                         // com\\googlecode\\sparkleg\\Sparql.g:387:65: ^( SUBJECT varOrTerm )
 12178   
                         {
 12179  826 
                         Object root_2 = (Object)adaptor.nil();
 12180  1034 
                         root_2 = (Object)adaptor.becomeRoot(
 12181   
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12182   
                         , root_2);
 12183  208 
 
 12184  826 
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12185   
 
 12186  826 
                         adaptor.addChild(root_1, root_2);
 12187  2 
                         }
 12188  2 
 
 12189   
                         // com\\googlecode\\sparkleg\\Sparql.g:387:86: ( propertyListNotEmpty )?
 12190  828 
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12191  826 
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12192  2 
 
 12193   
                         }
 12194  826 
                         stream_propertyListNotEmpty.reset();
 12195  2 
 
 12196  828 
                         adaptor.addChild(root_0, root_1);
 12197   
                         }
 12198   
 
 12199   
                     }
 12200   
 
 12201   
 
 12202  826 
                     retval.tree = root_0;
 12203   
 
 12204   
                     }
 12205  826 
                     break;
 12206   
                 case 2 :
 12207   
                     // com\\googlecode\\sparkleg\\Sparql.g:388:7: triplesNode ( propertyListNotEmpty )?
 12208   
                     {
 12209  8 
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubject3135);
 12210  8 
                     triplesNode270=triplesNode();
 12211   
 
 12212  10 
                     state._fsp--;
 12213   
 
 12214  8 
                     stream_triplesNode.add(triplesNode270.getTree());
 12215   
 
 12216   
                     // com\\googlecode\\sparkleg\\Sparql.g:388:19: ( propertyListNotEmpty )?
 12217  8 
                     int alt87=2;
 12218  8 
                     switch ( input.LA(1) ) {
 12219   
                         case A:
 12220   
                         case INVERSE:
 12221   
                         case IRI_REF:
 12222   
                         case NEGATION:
 12223   
                         case PNAME_LN:
 12224   
                         case PNAME_NS:
 12225   
                         case VAR1:
 12226   
                         case VAR2:
 12227   
                         case 209:
 12228   
                             {
 12229  0 
                             alt87=1;
 12230   
                             }
 12231   
                             break;
 12232   
                     }
 12233   
 
 12234  8 
                     switch (alt87) {
 12235   
                         case 1 :
 12236  2 
                             // com\\googlecode\\sparkleg\\Sparql.g:388:19: propertyListNotEmpty
 12237  2 
                             {
 12238  0 
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject3137);
 12239  2 
                             propertyListNotEmpty271=propertyListNotEmpty();
 12240   
 
 12241  0 
                             state._fsp--;
 12242   
 
 12243  0 
                             stream_propertyListNotEmpty.add(propertyListNotEmpty271.getTree());
 12244  2 
 
 12245  2 
                             }
 12246   
                             break;
 12247   
 
 12248   
                     }
 12249  2 
 
 12250   
 
 12251   
                     // AST REWRITE
 12252  2 
                     // elements: triplesNode, propertyListNotEmpty
 12253   
                     // token labels:
 12254   
                     // rule labels: retval
 12255   
                     // token list labels:
 12256  2 
                     // rule list labels:
 12257   
                     // wildcard labels:
 12258  10 
                     retval.tree = root_0;
 12259  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12260   
 
 12261  8 
                     root_0 = (Object)adaptor.nil();
 12262   
                     // 388:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12263   
                     {
 12264  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:388:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12265   
                         {
 12266  8 
                         Object root_1 = (Object)adaptor.nil();
 12267  8 
                         root_1 = (Object)adaptor.becomeRoot(
 12268   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12269   
                         , root_1);
 12270  210 
 
 12271  8 
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12272   
 
 12273  210 
                         // com\\googlecode\\sparkleg\\Sparql.g:388:79: ( propertyListNotEmpty )?
 12274  218 
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12275  0 
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12276   
 
 12277   
                         }
 12278  8 
                         stream_propertyListNotEmpty.reset();
 12279   
 
 12280  8 
                         adaptor.addChild(root_0, root_1);
 12281   
                         }
 12282   
 
 12283   
                     }
 12284   
 
 12285   
 
 12286  218 
                     retval.tree = root_0;
 12287  210 
 
 12288   
                     }
 12289   
                     break;
 12290   
 
 12291   
             }
 12292  834 
             retval.stop = input.LT(-1);
 12293   
 
 12294  246 
 
 12295  834 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12296  834 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12297   
 
 12298   
         }
 12299  0 
         catch (RecognitionException re) {
 12300  0 
             reportError(re);
 12301  246 
             recover(input,re);
 12302  246 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12303   
 
 12304   
         }
 12305  246 
 
 12306  0 
         finally {
 12307  246 
                 // do for sure before leaving
 12308  1080 
         }
 12309  834 
         return retval;
 12310  246 
     }
 12311   
     // $ANTLR end "triplesSameSubject"
 12312   
 
 12313  246 
 
 12314  246 
     public static class propertyListNotEmpty_return extends ParserRuleReturnScope {
 12315  246 
         Object tree;
 12316  1008 
         public Object getTree() { return tree; }
 12317   
     };
 12318   
 
 12319   
 
 12320  246 
     // $ANTLR start "propertyListNotEmpty"
 12321  246 
     // com\\googlecode\\sparkleg\\Sparql.g:391:1: propertyListNotEmpty : propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12322   
     public final SparqlParser.propertyListNotEmpty_return propertyListNotEmpty() throws RecognitionException {
 12323  1254 
         SparqlParser.propertyListNotEmpty_return retval = new SparqlParser.propertyListNotEmpty_return();
 12324  1008 
         retval.start = input.LT(1);
 12325  246 
 
 12326   
 
 12327  1008 
         Object root_0 = null;
 12328   
 
 12329  1008 
         Token char_literal273=null;
 12330  1284 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails272 =null;
 12331  276 
 
 12332  1008 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails274 =null;
 12333   
 
 12334  30 
 
 12335  1008 
         Object char_literal273_tree=null;
 12336  1008 
         RewriteRuleTokenStream stream_212=new RewriteRuleTokenStream(adaptor,"token 212");
 12337  1008 
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12338   
         try {
 12339   
             // com\\googlecode\\sparkleg\\Sparql.g:392:5: ( propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12340  276 
             // com\\googlecode\\sparkleg\\Sparql.g:392:7: propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )*
 12341   
             {
 12342  1008 
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3167);
 12343  1008 
             propertyListNotEmptyDetails272=propertyListNotEmptyDetails();
 12344  30 
 
 12345  1038 
             state._fsp--;
 12346   
 
 12347  1008 
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails272.getTree());
 12348   
 
 12349  30 
             // com\\googlecode\\sparkleg\\Sparql.g:392:35: ( ';' ( propertyListNotEmptyDetails )? )*
 12350  30 
             loop90:
 12351   
             do {
 12352  1137 
                 int alt90=2;
 12353  1137 
                 switch ( input.LA(1) ) {
 12354   
                 case 212:
 12355   
                     {
 12356  129 
                     alt90=1;
 12357   
                     }
 12358   
                     break;
 12359   
 
 12360   
                 }
 12361  28 
 
 12362  1137 
                 switch (alt90) {
 12363   
                     case 1 :
 12364   
                         // com\\googlecode\\sparkleg\\Sparql.g:392:36: ';' ( propertyListNotEmptyDetails )?
 12365   
                         {
 12366  159 
                         char_literal273=(Token)match(input,212,FOLLOW_212_in_propertyListNotEmpty3170);
 12367  129 
                         stream_212.add(char_literal273);
 12368   
 
 12369   
 
 12370  28 
                         // com\\googlecode\\sparkleg\\Sparql.g:392:40: ( propertyListNotEmptyDetails )?
 12371  157 
                         int alt89=2;
 12372  129 
                         switch ( input.LA(1) ) {
 12373  28 
                             case A:
 12374   
                             case INVERSE:
 12375  28 
                             case IRI_REF:
 12376   
                             case NEGATION:
 12377   
                             case PNAME_LN:
 12378   
                             case PNAME_NS:
 12379   
                             case VAR1:
 12380   
                             case VAR2:
 12381   
                             case 209:
 12382   
                                 {
 12383  124 
                                 alt89=1;
 12384  30 
                                 }
 12385   
                                 break;
 12386   
                         }
 12387  246 
 
 12388  129 
                         switch (alt89) {
 12389  30 
                             case 1 :
 12390   
                                 // com\\googlecode\\sparkleg\\Sparql.g:392:40: propertyListNotEmptyDetails
 12391   
                                 {
 12392  124 
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3172);
 12393  124 
                                 propertyListNotEmptyDetails274=propertyListNotEmptyDetails();
 12394   
 
 12395  124 
                                 state._fsp--;
 12396   
 
 12397  124 
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails274.getTree());
 12398   
 
 12399  246 
                                 }
 12400  246 
                                 break;
 12401   
 
 12402  246 
                         }
 12403   
 
 12404   
 
 12405  246 
                         }
 12406  129 
                         break;
 12407   
 
 12408  520 
                     default :
 12409  1282 
                         break loop90;
 12410   
                 }
 12411  129 
             } while (true);
 12412  246 
 
 12413   
 
 12414   
             // AST REWRITE
 12415   
             // elements: propertyListNotEmptyDetails
 12416   
             // token labels:
 12417  246 
             // rule labels: retval
 12418   
             // token list labels:
 12419   
             // rule list labels:
 12420   
             // wildcard labels:
 12421  1254 
             retval.tree = root_0;
 12422  1008 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12423   
 
 12424  1254 
             root_0 = (Object)adaptor.nil();
 12425  246 
             // 392:71: -> ( propertyListNotEmptyDetails )+
 12426   
             {
 12427  1008 
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 12428  0 
                     throw new RewriteEarlyExitException();
 12429   
                 }
 12430  2140 
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 12431  1132 
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 12432   
 
 12433   
                 }
 12434  1008 
                 stream_propertyListNotEmptyDetails.reset();
 12435   
 
 12436   
             }
 12437  246 
 
 12438  246 
 
 12439  1008 
             retval.tree = root_0;
 12440   
 
 12441   
             }
 12442   
 
 12443  3392 
             retval.stop = input.LT(-1);
 12444   
 
 12445  3392 
 
 12446  1008 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12447  1008 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12448   
 
 12449   
         }
 12450  0 
         catch (RecognitionException re) {
 12451  0 
             reportError(re);
 12452  3392 
             recover(input,re);
 12453  3392 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12454   
 
 12455   
         }
 12456  3392 
 
 12457  0 
         finally {
 12458  3392 
                 // do for sure before leaving
 12459  4400 
         }
 12460  1008 
         return retval;
 12461  3392 
     }
 12462   
     // $ANTLR end "propertyListNotEmpty"
 12463   
 
 12464  3392 
 
 12465  13442 
     public static class objectList_return extends ParserRuleReturnScope {
 12466  3392 
         Object tree;
 12467  13442 
         public Object getTree() { return tree; }
 12468   
     };
 12469   
 
 12470   
 
 12471  3392 
     // $ANTLR start "objectList"
 12472  3392 
     // com\\googlecode\\sparkleg\\Sparql.g:395:1: objectList : graphNode ( ',' graphNode )* -> ( ^( OBJECT graphNode ) )+ ;
 12473   
     public final SparqlParser.objectList_return objectList() throws RecognitionException {
 12474  16834 
         SparqlParser.objectList_return retval = new SparqlParser.objectList_return();
 12475  13442 
         retval.start = input.LT(1);
 12476  3392 
 
 12477   
 
 12478  13442 
         Object root_0 = null;
 12479   
 
 12480  13442 
         Token char_literal276=null;
 12481  16848 
         SparqlParser.graphNode_return graphNode275 =null;
 12482  3406 
 
 12483  13442 
         SparqlParser.graphNode_return graphNode277 =null;
 12484   
 
 12485  14 
 
 12486  13442 
         Object char_literal276_tree=null;
 12487  13442 
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 12488  13442 
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 12489   
         try {
 12490   
             // com\\googlecode\\sparkleg\\Sparql.g:396:5: ( graphNode ( ',' graphNode )* -> ( ^( OBJECT graphNode ) )+ )
 12491  3406 
             // com\\googlecode\\sparkleg\\Sparql.g:396:7: graphNode ( ',' graphNode )*
 12492   
             {
 12493  13442 
             pushFollow(FOLLOW_graphNode_in_objectList3198);
 12494  13442 
             graphNode275=graphNode();
 12495  14 
 
 12496  13456 
             state._fsp--;
 12497   
 
 12498  13442 
             stream_graphNode.add(graphNode275.getTree());
 12499  14 
 
 12500  14 
             // com\\googlecode\\sparkleg\\Sparql.g:396:17: ( ',' graphNode )*
 12501   
             loop91:
 12502  14 
             do {
 12503  13468 
                 int alt91=2;
 12504  13482 
                 switch ( input.LA(1) ) {
 12505   
                 case 211:
 12506   
                     {
 12507  40 
                     alt91=1;
 12508   
                     }
 12509   
                     break;
 12510  3392 
 
 12511   
                 }
 12512  14 
 
 12513  13468 
                 switch (alt91) {
 12514   
                     case 1 :
 12515   
                         // com\\googlecode\\sparkleg\\Sparql.g:396:18: ',' graphNode
 12516   
                         {
 12517  26 
                         char_literal276=(Token)match(input,211,FOLLOW_211_in_objectList3201);
 12518  26 
                         stream_211.add(char_literal276);
 12519   
 
 12520   
 
 12521  26 
                         pushFollow(FOLLOW_graphNode_in_objectList3203);
 12522  3418 
                         graphNode277=graphNode();
 12523  3392 
 
 12524  26 
                         state._fsp--;
 12525  3392 
 
 12526  26 
                         stream_graphNode.add(graphNode277.getTree());
 12527   
 
 12528  3392 
                         }
 12529  26 
                         break;
 12530   
 
 12531  6798 
                     default :
 12532  13442 
                         break loop91;
 12533   
                 }
 12534  3432 
             } while (true);
 12535  3406 
 
 12536   
 
 12537   
             // AST REWRITE
 12538   
             // elements: graphNode
 12539  3406 
             // token labels:
 12540   
             // rule labels: retval
 12541  3406 
             // token list labels:
 12542  3406 
             // rule list labels:
 12543   
             // wildcard labels:
 12544  13442 
             retval.tree = root_0;
 12545  16834 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12546   
 
 12547  13442 
             root_0 = (Object)adaptor.nil();
 12548   
             // 396:34: -> ( ^( OBJECT graphNode ) )+
 12549   
             {
 12550  16834 
                 if ( !(stream_graphNode.hasNext()) ) {
 12551  0 
                     throw new RewriteEarlyExitException();
 12552   
                 }
 12553  26910 
                 while ( stream_graphNode.hasNext() ) {
 12554  3392 
                     // com\\googlecode\\sparkleg\\Sparql.g:396:37: ^( OBJECT graphNode )
 12555   
                     {
 12556  13468 
                     Object root_1 = (Object)adaptor.nil();
 12557  16860 
                     root_1 = (Object)adaptor.becomeRoot(
 12558  3392 
                     (Object)adaptor.create(OBJECT, "OBJECT")
 12559   
                     , root_1);
 12560   
 
 12561  13468 
                     adaptor.addChild(root_1, stream_graphNode.nextTree());
 12562   
 
 12563  13468 
                     adaptor.addChild(root_0, root_1);
 12564  13468 
                     }
 12565   
 
 12566   
                 }
 12567  13442 
                 stream_graphNode.reset();
 12568   
 
 12569   
             }
 12570  3392 
 
 12571  3392 
 
 12572  13442 
             retval.tree = root_0;
 12573   
 
 12574   
             }
 12575   
 
 12576  13442 
             retval.stop = input.LT(-1);
 12577   
 
 12578   
 
 12579  13442 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12580  13442 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12581   
 
 12582   
         }
 12583  0 
         catch (RecognitionException re) {
 12584  0 
             reportError(re);
 12585  0 
             recover(input,re);
 12586  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12587   
 
 12588   
         }
 12589   
 
 12590  0 
         finally {
 12591   
                 // do for sure before leaving
 12592  13442 
         }
 12593  13442 
         return retval;
 12594   
     }
 12595   
     // $ANTLR end "objectList"
 12596   
 
 12597   
 
 12598  0 
     public static class verb_return extends ParserRuleReturnScope {
 12599   
         Object tree;
 12600  0 
         public Object getTree() { return tree; }
 12601   
     };
 12602   
 
 12603   
 
 12604   
     // $ANTLR start "verb"
 12605   
     // com\\googlecode\\sparkleg\\Sparql.g:399:1: verb : ( varOrIRIref | A );
 12606   
     public final SparqlParser.verb_return verb() throws RecognitionException {
 12607  0 
         SparqlParser.verb_return retval = new SparqlParser.verb_return();
 12608  0 
         retval.start = input.LT(1);
 12609   
 
 12610   
 
 12611  0 
         Object root_0 = null;
 12612   
 
 12613  0 
         Token A279=null;
 12614  0 
         SparqlParser.varOrIRIref_return varOrIRIref278 =null;
 12615   
 
 12616   
 
 12617  0 
         Object A279_tree=null;
 12618   
 
 12619   
         try {
 12620   
             // com\\googlecode\\sparkleg\\Sparql.g:400:5: ( varOrIRIref | A )
 12621  0 
             int alt92=2;
 12622  0 
             switch ( input.LA(1) ) {
 12623   
             case IRI_REF:
 12624   
             case PNAME_LN:
 12625   
             case PNAME_NS:
 12626   
             case VAR1:
 12627   
             case VAR2:
 12628   
                 {
 12629  0 
                 alt92=1;
 12630   
                 }
 12631  0 
                 break;
 12632   
             case A:
 12633   
                 {
 12634  0 
                 alt92=2;
 12635   
                 }
 12636  0 
                 break;
 12637   
             default:
 12638  0 
                 NoViableAltException nvae =
 12639   
                     new NoViableAltException("", 92, 0, input);
 12640   
 
 12641  0 
                 throw nvae;
 12642   
 
 12643   
             }
 12644   
 
 12645  0 
             switch (alt92) {
 12646   
                 case 1 :
 12647   
                     // com\\googlecode\\sparkleg\\Sparql.g:400:7: varOrIRIref
 12648   
                     {
 12649  0 
                     root_0 = (Object)adaptor.nil();
 12650   
 
 12651   
 
 12652  0 
                     pushFollow(FOLLOW_varOrIRIref_in_verb3231);
 12653  0 
                     varOrIRIref278=varOrIRIref();
 12654   
 
 12655  0 
                     state._fsp--;
 12656   
 
 12657  0 
                     adaptor.addChild(root_0, varOrIRIref278.getTree());
 12658   
 
 12659   
                     }
 12660  0 
                     break;
 12661   
                 case 2 :
 12662   
                     // com\\googlecode\\sparkleg\\Sparql.g:401:7: A
 12663   
                     {
 12664  0 
                     root_0 = (Object)adaptor.nil();
 12665   
 
 12666   
 
 12667  0 
                     A279=(Token)match(input,A,FOLLOW_A_in_verb3239);
 12668  0 
                     A279_tree =
 12669   
                     (Object)adaptor.create(A279)
 12670   
                     ;
 12671  0 
                     adaptor.addChild(root_0, A279_tree);
 12672   
 
 12673   
 
 12674   
                     }
 12675   
                     break;
 12676   
 
 12677   
             }
 12678  2946 
             retval.stop = input.LT(-1);
 12679   
 
 12680  2946 
 
 12681  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12682  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12683   
 
 12684   
         }
 12685  0 
         catch (RecognitionException re) {
 12686  0 
             reportError(re);
 12687  2946 
             recover(input,re);
 12688  2946 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12689   
 
 12690   
         }
 12691  2946 
 
 12692  0 
         finally {
 12693  2946 
                 // do for sure before leaving
 12694  0 
         }
 12695  2946 
         return retval;
 12696   
     }
 12697  2946 
     // $ANTLR end "verb"
 12698   
 
 12699  2946 
 
 12700  11634 
     public static class triplesSameSubjectPath_return extends ParserRuleReturnScope {
 12701   
         Object tree;
 12702  11634 
         public Object getTree() { return tree; }
 12703  2946 
     };
 12704  2946 
 
 12705  2946 
 
 12706   
     // $ANTLR start "triplesSameSubjectPath"
 12707   
     // com\\googlecode\\sparkleg\\Sparql.g:404:1: triplesSameSubjectPath : ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 12708  2946 
     public final SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath() throws RecognitionException {
 12709  14580 
         SparqlParser.triplesSameSubjectPath_return retval = new SparqlParser.triplesSameSubjectPath_return();
 12710  11634 
         retval.start = input.LT(1);
 12711   
 
 12712   
 
 12713  11634 
         Object root_0 = null;
 12714   
 
 12715  11634 
         SparqlParser.varOrTerm_return varOrTerm280 =null;
 12716   
 
 12717  11634 
         SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath281 =null;
 12718   
 
 12719  11634 
         SparqlParser.triplesNode_return triplesNode282 =null;
 12720   
 
 12721  11634 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty283 =null;
 12722   
 
 12723   
 
 12724  11634 
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 12725  11634 
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 12726  11634 
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 12727  11634 
         RewriteRuleSubtreeStream stream_propertyListNotEmptyPath=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyPath");
 12728   
         try {
 12729   
             // com\\googlecode\\sparkleg\\Sparql.g:405:5: ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 12730  11634 
             int alt94=2;
 12731  11634 
             switch ( input.LA(1) ) {
 12732  2854 
             case BLANK_NODE_LABEL:
 12733   
             case DECIMAL:
 12734  2854 
             case DECIMAL_NEGATIVE:
 12735   
             case DECIMAL_POSITIVE:
 12736   
             case DOUBLE:
 12737  66 
             case DOUBLE_NEGATIVE:
 12738   
             case DOUBLE_POSITIVE:
 12739   
             case FALSE:
 12740  54 
             case INTEGER:
 12741   
             case INTEGER_NEGATIVE:
 12742  54 
             case INTEGER_POSITIVE:
 12743   
             case IRI_REF:
 12744   
             case PNAME_LN:
 12745   
             case PNAME_NS:
 12746   
             case STRING_LITERAL1:
 12747   
             case STRING_LITERAL2:
 12748   
             case STRING_LITERAL_LONG1:
 12749   
             case STRING_LITERAL_LONG2:
 12750   
             case TRUE:
 12751   
             case VAR1:
 12752   
             case VAR2:
 12753  8 
                 {
 12754  11278 
                 alt94=1;
 12755  8 
                 }
 12756  11278 
                 break;
 12757  4 
             case 213:
 12758   
                 {
 12759  264 
                 switch ( input.LA(2) ) {
 12760  4 
                 case 214:
 12761   
                     {
 12762  210 
                     alt94=1;
 12763   
                     }
 12764  210 
                     break;
 12765  62 
                 case A:
 12766   
                 case INVERSE:
 12767   
                 case IRI_REF:
 12768  26 
                 case NEGATION:
 12769   
                 case PNAME_LN:
 12770   
                 case PNAME_NS:
 12771  10 
                 case VAR1:
 12772   
                 case VAR2:
 12773  10 
                 case 209:
 12774   
                     {
 12775  50 
                     alt94=2;
 12776   
                     }
 12777  50 
                     break;
 12778   
                 default:
 12779  4 
                     NoViableAltException nvae =
 12780   
                         new NoViableAltException("", 94, 2, input);
 12781   
 
 12782  4 
                     throw nvae;
 12783   
 
 12784   
                 }
 12785   
 
 12786   
                 }
 12787  260 
                 break;
 12788   
             case 209:
 12789   
                 {
 12790  92 
                 switch ( input.LA(2) ) {
 12791   
                 case 210:
 12792   
                     {
 12793  28 
                     alt94=1;
 12794   
                     }
 12795  28 
                     break;
 12796   
                 case BLANK_NODE_LABEL:
 12797   
                 case DECIMAL:
 12798  16 
                 case DECIMAL_NEGATIVE:
 12799   
                 case DECIMAL_POSITIVE:
 12800  16 
                 case DOUBLE:
 12801   
                 case DOUBLE_NEGATIVE:
 12802   
                 case DOUBLE_POSITIVE:
 12803   
                 case FALSE:
 12804   
                 case INTEGER:
 12805   
                 case INTEGER_NEGATIVE:
 12806   
                 case INTEGER_POSITIVE:
 12807   
                 case IRI_REF:
 12808   
                 case PNAME_LN:
 12809   
                 case PNAME_NS:
 12810  26 
                 case STRING_LITERAL1:
 12811   
                 case STRING_LITERAL2:
 12812   
                 case STRING_LITERAL_LONG1:
 12813   
                 case STRING_LITERAL_LONG2:
 12814   
                 case TRUE:
 12815   
                 case VAR1:
 12816   
                 case VAR2:
 12817   
                 case 209:
 12818   
                 case 213:
 12819  2942 
                     {
 12820  64 
                     alt94=2;
 12821   
                     }
 12822  64 
                     break;
 12823  2918 
                 default:
 12824  2918 
                     NoViableAltException nvae =
 12825   
                         new NoViableAltException("", 94, 3, input);
 12826  2918 
 
 12827  0 
                     throw nvae;
 12828  2918 
 
 12829   
                 }
 12830  2918 
 
 12831  2918 
                 }
 12832  92 
                 break;
 12833  2918 
             default:
 12834  0 
                 NoViableAltException nvae =
 12835  2918 
                     new NoViableAltException("", 94, 0, input);
 12836   
 
 12837  0 
                 throw nvae;
 12838   
 
 12839   
             }
 12840   
 
 12841  11630 
             switch (alt94) {
 12842   
                 case 1 :
 12843   
                     // com\\googlecode\\sparkleg\\Sparql.g:405:7: varOrTerm propertyListNotEmptyPath
 12844  2918 
                     {
 12845  14434 
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubjectPath3256);
 12846  11516 
                     varOrTerm280=varOrTerm();
 12847  2918 
 
 12848  11516 
                     state._fsp--;
 12849   
 
 12850  11516 
                     stream_varOrTerm.add(varOrTerm280.getTree());
 12851   
 
 12852  14434 
                     pushFollow(FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3258);
 12853  14434 
                     propertyListNotEmptyPath281=propertyListNotEmptyPath();
 12854   
 
 12855  11516 
                     state._fsp--;
 12856   
 
 12857  11516 
                     stream_propertyListNotEmptyPath.add(propertyListNotEmptyPath281.getTree());
 12858   
 
 12859  2918 
                     // AST REWRITE
 12860  2918 
                     // elements: propertyListNotEmptyPath, varOrTerm
 12861   
                     // token labels:
 12862   
                     // rule labels: retval
 12863   
                     // token list labels:
 12864  2918 
                     // rule list labels:
 12865   
                     // wildcard labels:
 12866  14434 
                     retval.tree = root_0;
 12867  11516 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12868   
 
 12869  14434 
                     root_0 = (Object)adaptor.nil();
 12870   
                     // 405:42: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12871  2918 
                     {
 12872   
                         // com\\googlecode\\sparkleg\\Sparql.g:405:45: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12873   
                         {
 12874  11516 
                         Object root_1 = (Object)adaptor.nil();
 12875  11516 
                         root_1 = (Object)adaptor.becomeRoot(
 12876   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12877  2918 
                         , root_1);
 12878   
 
 12879   
                         // com\\googlecode\\sparkleg\\Sparql.g:405:68: ^( SUBJECT varOrTerm )
 12880  2918 
                         {
 12881  11516 
                         Object root_2 = (Object)adaptor.nil();
 12882  11516 
                         root_2 = (Object)adaptor.becomeRoot(
 12883   
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12884  24 
                         , root_2);
 12885  24 
 
 12886  11516 
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12887  24 
 
 12888  11516 
                         adaptor.addChild(root_1, root_2);
 12889  24 
                         }
 12890   
 
 12891  11516 
                         adaptor.addChild(root_1, stream_propertyListNotEmptyPath.nextTree());
 12892  24 
 
 12893  11540 
                         adaptor.addChild(root_0, root_1);
 12894   
                         }
 12895   
 
 12896   
                     }
 12897   
 
 12898   
 
 12899  11516 
                     retval.tree = root_0;
 12900   
 
 12901   
                     }
 12902  11516 
                     break;
 12903   
                 case 2 :
 12904  8 
                     // com\\googlecode\\sparkleg\\Sparql.g:406:7: triplesNode ( propertyListNotEmpty )?
 12905   
                     {
 12906  114 
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubjectPath3280);
 12907  114 
                     triplesNode282=triplesNode();
 12908   
 
 12909  138 
                     state._fsp--;
 12910   
 
 12911  114 
                     stream_triplesNode.add(triplesNode282.getTree());
 12912   
 
 12913  8 
                     // com\\googlecode\\sparkleg\\Sparql.g:406:19: ( propertyListNotEmpty )?
 12914  122 
                     int alt93=2;
 12915  114 
                     switch ( input.LA(1) ) {
 12916  8 
                         case A:
 12917   
                         case INVERSE:
 12918  8 
                         case IRI_REF:
 12919   
                         case NEGATION:
 12920   
                         case PNAME_LN:
 12921   
                         case PNAME_NS:
 12922   
                         case VAR1:
 12923   
                         case VAR2:
 12924   
                         case 209:
 12925   
                             {
 12926  38 
                             alt93=1;
 12927   
                             }
 12928   
                             break;
 12929   
                     }
 12930   
 
 12931  114 
                     switch (alt93) {
 12932   
                         case 1 :
 12933  24 
                             // com\\googlecode\\sparkleg\\Sparql.g:406:19: propertyListNotEmpty
 12934  24 
                             {
 12935  38 
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3282);
 12936  62 
                             propertyListNotEmpty283=propertyListNotEmpty();
 12937   
 
 12938  38 
                             state._fsp--;
 12939   
 
 12940  38 
                             stream_propertyListNotEmpty.add(propertyListNotEmpty283.getTree());
 12941  24 
 
 12942  24 
                             }
 12943   
                             break;
 12944   
 
 12945   
                     }
 12946  24 
 
 12947   
 
 12948   
                     // AST REWRITE
 12949  24 
                     // elements: propertyListNotEmpty, triplesNode
 12950  8 
                     // token labels:
 12951   
                     // rule labels: retval
 12952   
                     // token list labels:
 12953  24 
                     // rule list labels:
 12954   
                     // wildcard labels:
 12955  138 
                     retval.tree = root_0;
 12956  114 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12957   
 
 12958  114 
                     root_0 = (Object)adaptor.nil();
 12959   
                     // 406:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12960   
                     {
 12961  24 
                         // com\\googlecode\\sparkleg\\Sparql.g:406:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12962   
                         {
 12963  114 
                         Object root_1 = (Object)adaptor.nil();
 12964  114 
                         root_1 = (Object)adaptor.becomeRoot(
 12965   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12966   
                         , root_1);
 12967  2942 
 
 12968  114 
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12969   
 
 12970  2942 
                         // com\\googlecode\\sparkleg\\Sparql.g:406:80: ( propertyListNotEmpty )?
 12971  3056 
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12972  38 
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12973   
 
 12974  4 
                         }
 12975  118 
                         stream_propertyListNotEmpty.reset();
 12976  4 
 
 12977  118 
                         adaptor.addChild(root_0, root_1);
 12978   
                         }
 12979   
 
 12980   
                     }
 12981   
 
 12982   
 
 12983  3060 
                     retval.tree = root_0;
 12984  2946 
 
 12985   
                     }
 12986   
                     break;
 12987   
 
 12988   
             }
 12989  11630 
             retval.stop = input.LT(-1);
 12990   
 
 12991  2918 
 
 12992  11630 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12993  11630 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12994   
 
 12995   
         }
 12996  4 
         catch (RecognitionException re) {
 12997  4 
             reportError(re);
 12998  2922 
             recover(input,re);
 12999  2922 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13000   
 
 13001   
         }
 13002  2918 
 
 13003  0 
         finally {
 13004  2918 
                 // do for sure before leaving
 13005  14552 
         }
 13006  11634 
         return retval;
 13007  2918 
     }
 13008   
     // $ANTLR end "triplesSameSubjectPath"
 13009   
 
 13010  2918 
 
 13011  2918 
     public static class propertyListNotEmptyPath_return extends ParserRuleReturnScope {
 13012  2918 
         Object tree;
 13013  11516 
         public Object getTree() { return tree; }
 13014   
     };
 13015   
 
 13016   
 
 13017  2918 
     // $ANTLR start "propertyListNotEmptyPath"
 13018  2918 
     // com\\googlecode\\sparkleg\\Sparql.g:409:1: propertyListNotEmptyPath : propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 13019   
     public final SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath() throws RecognitionException {
 13020  14434 
         SparqlParser.propertyListNotEmptyPath_return retval = new SparqlParser.propertyListNotEmptyPath_return();
 13021  11516 
         retval.start = input.LT(1);
 13022  2918 
 
 13023   
 
 13024  11516 
         Object root_0 = null;
 13025   
 
 13026  11516 
         Token char_literal285=null;
 13027  14646 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails284 =null;
 13028  3130 
 
 13029  11516 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails286 =null;
 13030   
 
 13031  212 
 
 13032  11516 
         Object char_literal285_tree=null;
 13033  11516 
         RewriteRuleTokenStream stream_212=new RewriteRuleTokenStream(adaptor,"token 212");
 13034  11516 
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 13035   
         try {
 13036   
             // com\\googlecode\\sparkleg\\Sparql.g:410:5: ( propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 13037  3130 
             // com\\googlecode\\sparkleg\\Sparql.g:410:7: propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )*
 13038   
             {
 13039  11516 
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3314);
 13040  11516 
             propertyListNotEmptyDetails284=propertyListNotEmptyDetails();
 13041  212 
 
 13042  11728 
             state._fsp--;
 13043   
 
 13044  11516 
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails284.getTree());
 13045   
 
 13046  212 
             // com\\googlecode\\sparkleg\\Sparql.g:410:35: ( ';' ( propertyListNotEmptyDetails )? )*
 13047  212 
             loop96:
 13048   
             do {
 13049  12334 
                 int alt96=2;
 13050  12334 
                 switch ( input.LA(1) ) {
 13051   
                 case 212:
 13052   
                     {
 13053  818 
                     alt96=1;
 13054   
                     }
 13055   
                     break;
 13056   
 
 13057   
                 }
 13058  200 
 
 13059  12334 
                 switch (alt96) {
 13060   
                     case 1 :
 13061   
                         // com\\googlecode\\sparkleg\\Sparql.g:410:36: ';' ( propertyListNotEmptyDetails )?
 13062   
                         {
 13063  1030 
                         char_literal285=(Token)match(input,212,FOLLOW_212_in_propertyListNotEmptyPath3317);
 13064  818 
                         stream_212.add(char_literal285);
 13065   
 
 13066   
 
 13067  200 
                         // com\\googlecode\\sparkleg\\Sparql.g:410:40: ( propertyListNotEmptyDetails )?
 13068  1018 
                         int alt95=2;
 13069  818 
                         switch ( input.LA(1) ) {
 13070  200 
                             case A:
 13071   
                             case INVERSE:
 13072  200 
                             case IRI_REF:
 13073   
                             case NEGATION:
 13074   
                             case PNAME_LN:
 13075   
                             case PNAME_NS:
 13076   
                             case VAR1:
 13077   
                             case VAR2:
 13078   
                             case 209:
 13079   
                                 {
 13080  794 
                                 alt95=1;
 13081  212 
                                 }
 13082   
                                 break;
 13083   
                         }
 13084  2918 
 
 13085  818 
                         switch (alt95) {
 13086  212 
                             case 1 :
 13087   
                                 // com\\googlecode\\sparkleg\\Sparql.g:410:40: propertyListNotEmptyDetails
 13088   
                                 {
 13089  794 
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3319);
 13090  794 
                                 propertyListNotEmptyDetails286=propertyListNotEmptyDetails();
 13091   
 
 13092  794 
                                 state._fsp--;
 13093   
 
 13094  794 
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails286.getTree());
 13095   
 
 13096  2918 
                                 }
 13097  2918 
                                 break;
 13098   
 
 13099  2918 
                         }
 13100   
 
 13101   
 
 13102  2918 
                         }
 13103  818 
                         break;
 13104   
 
 13105  6036 
                     default :
 13106  14634 
                         break loop96;
 13107   
                 }
 13108  818 
             } while (true);
 13109  2918 
 
 13110   
 
 13111   
             // AST REWRITE
 13112   
             // elements: propertyListNotEmptyDetails
 13113   
             // token labels:
 13114  2918 
             // rule labels: retval
 13115   
             // token list labels:
 13116   
             // rule list labels:
 13117   
             // wildcard labels:
 13118  14434 
             retval.tree = root_0;
 13119  11516 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13120   
 
 13121  14434 
             root_0 = (Object)adaptor.nil();
 13122  2918 
             // 410:71: -> ( propertyListNotEmptyDetails )+
 13123   
             {
 13124  11516 
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 13125  0 
                     throw new RewriteEarlyExitException();
 13126   
                 }
 13127  23826 
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 13128  12310 
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 13129   
 
 13130   
                 }
 13131  11516 
                 stream_propertyListNotEmptyDetails.reset();
 13132   
 
 13133   
             }
 13134  2918 
 
 13135  2918 
 
 13136  11516 
             retval.tree = root_0;
 13137   
 
 13138   
             }
 13139   
 
 13140  11516 
             retval.stop = input.LT(-1);
 13141   
 
 13142  3392 
 
 13143  11516 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13144  11516 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13145   
 
 13146   
         }
 13147  0 
         catch (RecognitionException re) {
 13148  0 
             reportError(re);
 13149  3392 
             recover(input,re);
 13150  3392 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13151   
 
 13152   
         }
 13153  3392 
 
 13154  0 
         finally {
 13155  3392 
                 // do for sure before leaving
 13156  11516 
         }
 13157  14908 
         return retval;
 13158   
     }
 13159   
     // $ANTLR end "propertyListNotEmptyPath"
 13160  3392 
 
 13161  3392 
 
 13162  13442 
     public static class propertyListNotEmptyDetails_return extends ParserRuleReturnScope {
 13163   
         Object tree;
 13164  13442 
         public Object getTree() { return tree; }
 13165   
     };
 13166  3392 
 
 13167  3392 
 
 13168   
     // $ANTLR start "propertyListNotEmptyDetails"
 13169  3392 
     // com\\googlecode\\sparkleg\\Sparql.g:413:1: propertyListNotEmptyDetails : verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) ;
 13170   
     public final SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails() throws RecognitionException {
 13171  16834 
         SparqlParser.propertyListNotEmptyDetails_return retval = new SparqlParser.propertyListNotEmptyDetails_return();
 13172  13442 
         retval.start = input.LT(1);
 13173  3392 
 
 13174  3392 
 
 13175  13442 
         Object root_0 = null;
 13176  3392 
 
 13177  13442 
         SparqlParser.verbSimpleOrPath_return verbSimpleOrPath287 =null;
 13178  3392 
 
 13179  13442 
         SparqlParser.objectList_return objectList288 =null;
 13180   
 
 13181   
 
 13182  13442 
         RewriteRuleSubtreeStream stream_verbSimpleOrPath=new RewriteRuleSubtreeStream(adaptor,"rule verbSimpleOrPath");
 13183  13442 
         RewriteRuleSubtreeStream stream_objectList=new RewriteRuleSubtreeStream(adaptor,"rule objectList");
 13184   
         try {
 13185   
             // com\\googlecode\\sparkleg\\Sparql.g:414:5: ( verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) )
 13186   
             // com\\googlecode\\sparkleg\\Sparql.g:414:7: verbSimpleOrPath objectList
 13187  3392 
             {
 13188  16834 
             pushFollow(FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3346);
 13189  13442 
             verbSimpleOrPath287=verbSimpleOrPath();
 13190  3392 
 
 13191  13442 
             state._fsp--;
 13192   
 
 13193  13442 
             stream_verbSimpleOrPath.add(verbSimpleOrPath287.getTree());
 13194   
 
 13195  16834 
             pushFollow(FOLLOW_objectList_in_propertyListNotEmptyDetails3348);
 13196  16834 
             objectList288=objectList();
 13197   
 
 13198  13442 
             state._fsp--;
 13199   
 
 13200  16834 
             stream_objectList.add(objectList288.getTree());
 13201   
 
 13202  3392 
             // AST REWRITE
 13203   
             // elements: verbSimpleOrPath, objectList
 13204  3392 
             // token labels:
 13205   
             // rule labels: retval
 13206   
             // token list labels:
 13207   
             // rule list labels:
 13208   
             // wildcard labels:
 13209  13442 
             retval.tree = root_0;
 13210  16834 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13211   
 
 13212  13442 
             root_0 = (Object)adaptor.nil();
 13213   
             // 414:35: -> ^( PREDICATE verbSimpleOrPath objectList )
 13214  3392 
             {
 13215   
                 // com\\googlecode\\sparkleg\\Sparql.g:414:38: ^( PREDICATE verbSimpleOrPath objectList )
 13216   
                 {
 13217  16834 
                 Object root_1 = (Object)adaptor.nil();
 13218  16834 
                 root_1 = (Object)adaptor.becomeRoot(
 13219   
                 (Object)adaptor.create(PREDICATE, "PREDICATE")
 13220   
                 , root_1);
 13221   
 
 13222  13442 
                 adaptor.addChild(root_1, stream_verbSimpleOrPath.nextTree());
 13223   
 
 13224  13442 
                 adaptor.addChild(root_1, stream_objectList.nextTree());
 13225   
 
 13226  13442 
                 adaptor.addChild(root_0, root_1);
 13227   
                 }
 13228   
 
 13229   
             }
 13230  3392 
 
 13231  3392 
 
 13232  13442 
             retval.tree = root_0;
 13233   
 
 13234   
             }
 13235   
 
 13236  3392 
             retval.stop = input.LT(-1);
 13237   
 
 13238  3392 
 
 13239  13442 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13240  13442 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13241   
 
 13242   
         }
 13243  0 
         catch (RecognitionException re) {
 13244  0 
             reportError(re);
 13245  3392 
             recover(input,re);
 13246  3392 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13247   
 
 13248   
         }
 13249  3392 
 
 13250  0 
         finally {
 13251  3392 
                 // do for sure before leaving
 13252  13442 
         }
 13253  16834 
         return retval;
 13254   
     }
 13255   
     // $ANTLR end "propertyListNotEmptyDetails"
 13256   
 
 13257   
 
 13258  13442 
     public static class verbSimpleOrPath_return extends ParserRuleReturnScope {
 13259  3392 
         Object tree;
 13260  13442 
         public Object getTree() { return tree; }
 13261   
     };
 13262   
 
 13263   
 
 13264   
     // $ANTLR start "verbSimpleOrPath"
 13265   
     // com\\googlecode\\sparkleg\\Sparql.g:417:1: verbSimpleOrPath : ( verbPath | verbSimple );
 13266   
     public final SparqlParser.verbSimpleOrPath_return verbSimpleOrPath() throws RecognitionException {
 13267  13442 
         SparqlParser.verbSimpleOrPath_return retval = new SparqlParser.verbSimpleOrPath_return();
 13268  13442 
         retval.start = input.LT(1);
 13269  2672 
 
 13270   
 
 13271  16114 
         Object root_0 = null;
 13272   
 
 13273  13442 
         SparqlParser.verbPath_return verbPath289 =null;
 13274   
 
 13275  14142 
         SparqlParser.verbSimple_return verbSimple290 =null;
 13276   
 
 13277  700 
 
 13278   
 
 13279  20 
         try {
 13280   
             // com\\googlecode\\sparkleg\\Sparql.g:418:5: ( verbPath | verbSimple )
 13281  13442 
             int alt97=2;
 13282  13462 
             switch ( input.LA(1) ) {
 13283   
             case A:
 13284   
             case INVERSE:
 13285   
             case IRI_REF:
 13286  3372 
             case NEGATION:
 13287   
             case PNAME_LN:
 13288   
             case PNAME_NS:
 13289   
             case 209:
 13290  2672 
                 {
 13291  10670 
                 alt97=1;
 13292   
                 }
 13293  13342 
                 break;
 13294  2672 
             case VAR1:
 13295   
             case VAR2:
 13296  2672 
                 {
 13297  2752 
                 alt97=2;
 13298  2672 
                 }
 13299  2752 
                 break;
 13300   
             default:
 13301  2692 
                 NoViableAltException nvae =
 13302   
                     new NoViableAltException("", 97, 0, input);
 13303   
 
 13304  20 
                 throw nvae;
 13305  700 
 
 13306   
             }
 13307   
 
 13308  14122 
             switch (alt97) {
 13309  700 
                 case 1 :
 13310   
                     // com\\googlecode\\sparkleg\\Sparql.g:418:7: verbPath
 13311  700 
                     {
 13312  10670 
                     root_0 = (Object)adaptor.nil();
 13313  700 
 
 13314   
 
 13315  10670 
                     pushFollow(FOLLOW_verbPath_in_verbSimpleOrPath3378);
 13316  10670 
                     verbPath289=verbPath();
 13317   
 
 13318  10670 
                     state._fsp--;
 13319  3372 
 
 13320  10670 
                     adaptor.addChild(root_0, verbPath289.getTree());
 13321   
 
 13322  3372 
                     }
 13323  14042 
                     break;
 13324   
                 case 2 :
 13325   
                     // com\\googlecode\\sparkleg\\Sparql.g:419:7: verbSimple
 13326  20 
                     {
 13327  2772 
                     root_0 = (Object)adaptor.nil();
 13328  20 
 
 13329  20 
 
 13330  2752 
                     pushFollow(FOLLOW_verbSimple_in_verbSimpleOrPath3386);
 13331  2752 
                     verbSimple290=verbSimple();
 13332   
 
 13333  2752 
                     state._fsp--;
 13334   
 
 13335  6144 
                     adaptor.addChild(root_0, verbSimple290.getTree());
 13336  3392 
 
 13337   
                     }
 13338   
                     break;
 13339   
 
 13340   
             }
 13341  2672 
             retval.stop = input.LT(-1);
 13342   
 
 13343  2672 
 
 13344  13422 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13345  13422 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13346   
 
 13347   
         }
 13348  20 
         catch (RecognitionException re) {
 13349  20 
             reportError(re);
 13350  2692 
             recover(input,re);
 13351  2692 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13352   
 
 13353   
         }
 13354  2672 
 
 13355  0 
         finally {
 13356  2672 
                 // do for sure before leaving
 13357  13442 
         }
 13358  13442 
         return retval;
 13359   
     }
 13360   
     // $ANTLR end "verbSimpleOrPath"
 13361   
 
 13362   
 
 13363  10670 
     public static class verbPath_return extends ParserRuleReturnScope {
 13364  2672 
         Object tree;
 13365  10670 
         public Object getTree() { return tree; }
 13366   
     };
 13367  2672 
 
 13368  2672 
 
 13369   
     // $ANTLR start "verbPath"
 13370  2672 
     // com\\googlecode\\sparkleg\\Sparql.g:422:1: verbPath : path ;
 13371   
     public final SparqlParser.verbPath_return verbPath() throws RecognitionException {
 13372  13342 
         SparqlParser.verbPath_return retval = new SparqlParser.verbPath_return();
 13373  10670 
         retval.start = input.LT(1);
 13374   
 
 13375   
 
 13376  13342 
         Object root_0 = null;
 13377   
 
 13378  10670 
         SparqlParser.path_return path291 =null;
 13379  2672 
 
 13380  2672 
 
 13381   
 
 13382   
         try {
 13383   
             // com\\googlecode\\sparkleg\\Sparql.g:423:5: ( path )
 13384   
             // com\\googlecode\\sparkleg\\Sparql.g:423:7: path
 13385   
             {
 13386  10670 
             root_0 = (Object)adaptor.nil();
 13387   
 
 13388   
 
 13389  10670 
             pushFollow(FOLLOW_path_in_verbPath3405);
 13390  10670 
             path291=path();
 13391   
 
 13392  13342 
             state._fsp--;
 13393  2672 
 
 13394  10670 
             adaptor.addChild(root_0, path291.getTree());
 13395   
 
 13396   
             }
 13397   
 
 13398  10670 
             retval.stop = input.LT(-1);
 13399   
 
 13400  700 
 
 13401  10670 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13402  10670 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13403   
 
 13404   
         }
 13405  0 
         catch (RecognitionException re) {
 13406  0 
             reportError(re);
 13407  700 
             recover(input,re);
 13408  700 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13409   
 
 13410   
         }
 13411  700 
 
 13412  0 
         finally {
 13413  700 
                 // do for sure before leaving
 13414  10670 
         }
 13415  10670 
         return retval;
 13416   
     }
 13417   
     // $ANTLR end "verbPath"
 13418   
 
 13419   
 
 13420  2752 
     public static class verbSimple_return extends ParserRuleReturnScope {
 13421  700 
         Object tree;
 13422  2752 
         public Object getTree() { return tree; }
 13423   
     };
 13424  700 
 
 13425  700 
 
 13426   
     // $ANTLR start "verbSimple"
 13427  700 
     // com\\googlecode\\sparkleg\\Sparql.g:426:1: verbSimple : var ;
 13428   
     public final SparqlParser.verbSimple_return verbSimple() throws RecognitionException {
 13429  3452 
         SparqlParser.verbSimple_return retval = new SparqlParser.verbSimple_return();
 13430  2752 
         retval.start = input.LT(1);
 13431   
 
 13432   
 
 13433  3452 
         Object root_0 = null;
 13434   
 
 13435  2752 
         SparqlParser.var_return var292 =null;
 13436  700 
 
 13437  700 
 
 13438   
 
 13439   
         try {
 13440   
             // com\\googlecode\\sparkleg\\Sparql.g:427:5: ( var )
 13441   
             // com\\googlecode\\sparkleg\\Sparql.g:427:7: var
 13442   
             {
 13443  2752 
             root_0 = (Object)adaptor.nil();
 13444   
 
 13445   
 
 13446  2752 
             pushFollow(FOLLOW_var_in_verbSimple3426);
 13447  2752 
             var292=var();
 13448   
 
 13449  3452 
             state._fsp--;
 13450  700 
 
 13451  2752 
             adaptor.addChild(root_0, var292.getTree());
 13452   
 
 13453   
             }
 13454   
 
 13455  2752 
             retval.stop = input.LT(-1);
 13456   
 
 13457  2692 
 
 13458  2752 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13459  2752 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13460   
 
 13461   
         }
 13462  0 
         catch (RecognitionException re) {
 13463  0 
             reportError(re);
 13464  2692 
             recover(input,re);
 13465  2692 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13466   
 
 13467   
         }
 13468  2692 
 
 13469  0 
         finally {
 13470  2692 
                 // do for sure before leaving
 13471  5444 
         }
 13472  2752 
         return retval;
 13473  2692 
     }
 13474   
     // $ANTLR end "verbSimple"
 13475   
 
 13476  2692 
 
 13477  2692 
     public static class path_return extends ParserRuleReturnScope {
 13478  2692 
         Object tree;
 13479  10750 
         public Object getTree() { return tree; }
 13480   
     };
 13481   
 
 13482   
 
 13483  2692 
     // $ANTLR start "path"
 13484  2692 
     // com\\googlecode\\sparkleg\\Sparql.g:430:1: path : pathSequence ( '|' pathSequence )* -> ^( PATH ( pathSequence )+ ) ;
 13485   
     public final SparqlParser.path_return path() throws RecognitionException {
 13486  13442 
         SparqlParser.path_return retval = new SparqlParser.path_return();
 13487  10750 
         retval.start = input.LT(1);
 13488  2692 
 
 13489   
 
 13490  10750 
         Object root_0 = null;
 13491   
 
 13492  10750 
         Token char_literal294=null;
 13493  13462 
         SparqlParser.pathSequence_return pathSequence293 =null;
 13494  2712 
 
 13495  10750 
         SparqlParser.pathSequence_return pathSequence295 =null;
 13496   
 
 13497  20 
 
 13498  10750 
         Object char_literal294_tree=null;
 13499  10750 
         RewriteRuleTokenStream stream_217=new RewriteRuleTokenStream(adaptor,"token 217");
 13500  10750 
         RewriteRuleSubtreeStream stream_pathSequence=new RewriteRuleSubtreeStream(adaptor,"rule pathSequence");
 13501   
         try {
 13502   
             // com\\googlecode\\sparkleg\\Sparql.g:431:5: ( pathSequence ( '|' pathSequence )* -> ^( PATH ( pathSequence )+ ) )
 13503  2712 
             // com\\googlecode\\sparkleg\\Sparql.g:431:7: pathSequence ( '|' pathSequence )*
 13504   
             {
 13505  10750 
             pushFollow(FOLLOW_pathSequence_in_path3448);
 13506  10750 
             pathSequence293=pathSequence();
 13507  20 
 
 13508  10770 
             state._fsp--;
 13509   
 
 13510  10750 
             stream_pathSequence.add(pathSequence293.getTree());
 13511  20 
 
 13512  20 
             // com\\googlecode\\sparkleg\\Sparql.g:431:20: ( '|' pathSequence )*
 13513   
             loop98:
 13514  20 
             do {
 13515  10830 
                 int alt98=2;
 13516  10850 
                 switch ( input.LA(1) ) {
 13517   
                 case 217:
 13518   
                     {
 13519  100 
                     alt98=1;
 13520   
                     }
 13521   
                     break;
 13522  2692 
 
 13523   
                 }
 13524  20 
 
 13525  10830 
                 switch (alt98) {
 13526   
                     case 1 :
 13527   
                         // com\\googlecode\\sparkleg\\Sparql.g:431:21: '|' pathSequence
 13528   
                         {
 13529  80 
                         char_literal294=(Token)match(input,217,FOLLOW_217_in_path3451);
 13530  80 
                         stream_217.add(char_literal294);
 13531   
 
 13532   
 
 13533  80 
                         pushFollow(FOLLOW_pathSequence_in_path3453);
 13534  2772 
                         pathSequence295=pathSequence();
 13535  2692 
 
 13536  80 
                         state._fsp--;
 13537  2692 
 
 13538  80 
                         stream_pathSequence.add(pathSequence295.getTree());
 13539   
 
 13540   
                         }
 13541  80 
                         break;
 13542  2692 
 
 13543  2692 
                     default :
 13544  10750 
                         break loop98;
 13545   
                 }
 13546  80 
             } while (true);
 13547  2692 
 
 13548   
 
 13549   
             // AST REWRITE
 13550  5404 
             // elements: pathSequence
 13551  2712 
             // token labels:
 13552   
             // rule labels: retval
 13553   
             // token list labels:
 13554  2692 
             // rule list labels:
 13555   
             // wildcard labels:
 13556  13442 
             retval.tree = root_0;
 13557  10750 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13558   
 
 13559  10750 
             root_0 = (Object)adaptor.nil();
 13560   
             // 431:40: -> ^( PATH ( pathSequence )+ )
 13561   
             {
 13562  2692 
                 // com\\googlecode\\sparkleg\\Sparql.g:431:43: ^( PATH ( pathSequence )+ )
 13563   
                 {
 13564  10750 
                 Object root_1 = (Object)adaptor.nil();
 13565  10750 
                 root_1 = (Object)adaptor.becomeRoot(
 13566  2692 
                 (Object)adaptor.create(PATH, "PATH")
 13567   
                 , root_1);
 13568   
 
 13569  13442 
                 if ( !(stream_pathSequence.hasNext()) ) {
 13570  2692 
                     throw new RewriteEarlyExitException();
 13571   
                 }
 13572  21580 
                 while ( stream_pathSequence.hasNext() ) {
 13573  10830 
                     adaptor.addChild(root_1, stream_pathSequence.nextTree());
 13574   
 
 13575   
                 }
 13576  10750 
                 stream_pathSequence.reset();
 13577   
 
 13578  10750 
                 adaptor.addChild(root_0, root_1);
 13579   
                 }
 13580   
 
 13581   
             }
 13582  2692 
 
 13583  2692 
 
 13584  10750 
             retval.tree = root_0;
 13585   
 
 13586   
             }
 13587   
 
 13588  10750 
             retval.stop = input.LT(-1);
 13589   
 
 13590  2712 
 
 13591  10750 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13592  10750 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13593   
 
 13594   
         }
 13595  0 
         catch (RecognitionException re) {
 13596  0 
             reportError(re);
 13597  2712 
             recover(input,re);
 13598  2712 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13599   
 
 13600   
         }
 13601  2712 
 
 13602  0 
         finally {
 13603  2712 
                 // do for sure before leaving
 13604  13462 
         }
 13605  10750 
         return retval;
 13606  2712 
     }
 13607   
     // $ANTLR end "path"
 13608   
 
 13609  2712 
 
 13610  2712 
     public static class pathSequence_return extends ParserRuleReturnScope {
 13611  2712 
         Object tree;
 13612  10830 
         public Object getTree() { return tree; }
 13613   
     };
 13614   
 
 13615   
 
 13616  2712 
     // $ANTLR start "pathSequence"
 13617  2712 
     // com\\googlecode\\sparkleg\\Sparql.g:434:1: pathSequence : pathEltOrInverse ( '/' pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) ;
 13618   
     public final SparqlParser.pathSequence_return pathSequence() throws RecognitionException {
 13619  13542 
         SparqlParser.pathSequence_return retval = new SparqlParser.pathSequence_return();
 13620  10830 
         retval.start = input.LT(1);
 13621  2712 
 
 13622   
 
 13623  10830 
         Object root_0 = null;
 13624   
 
 13625  10830 
         Token char_literal297=null;
 13626  13606 
         SparqlParser.pathEltOrInverse_return pathEltOrInverse296 =null;
 13627  2776 
 
 13628  10830 
         SparqlParser.pathEltOrInverse_return pathEltOrInverse298 =null;
 13629   
 
 13630  64 
 
 13631  10830 
         Object char_literal297_tree=null;
 13632  10830 
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 13633  10830 
         RewriteRuleSubtreeStream stream_pathEltOrInverse=new RewriteRuleSubtreeStream(adaptor,"rule pathEltOrInverse");
 13634   
         try {
 13635   
             // com\\googlecode\\sparkleg\\Sparql.g:435:5: ( pathEltOrInverse ( '/' pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) )
 13636  2776 
             // com\\googlecode\\sparkleg\\Sparql.g:435:7: pathEltOrInverse ( '/' pathEltOrInverse )*
 13637   
             {
 13638  10830 
             pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3482);
 13639  10830 
             pathEltOrInverse296=pathEltOrInverse();
 13640  64 
 
 13641  10894 
             state._fsp--;
 13642   
 
 13643  10830 
             stream_pathEltOrInverse.add(pathEltOrInverse296.getTree());
 13644  64 
 
 13645  64 
             // com\\googlecode\\sparkleg\\Sparql.g:435:24: ( '/' pathEltOrInverse )*
 13646   
             loop99:
 13647  64 
             do {
 13648  11086 
                 int alt99=2;
 13649  11150 
                 switch ( input.LA(1) ) {
 13650   
                 case DIVIDE:
 13651   
                     {
 13652  320 
                     alt99=1;
 13653   
                     }
 13654   
                     break;
 13655  2712 
 
 13656   
                 }
 13657  64 
 
 13658  11086 
                 switch (alt99) {
 13659   
                     case 1 :
 13660   
                         // com\\googlecode\\sparkleg\\Sparql.g:435:25: '/' pathEltOrInverse
 13661   
                         {
 13662  256 
                         char_literal297=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_pathSequence3485);
 13663  256 
                         stream_DIVIDE.add(char_literal297);
 13664   
 
 13665   
 
 13666  256 
                         pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3487);
 13667  2968 
                         pathEltOrInverse298=pathEltOrInverse();
 13668  2712 
 
 13669  256 
                         state._fsp--;
 13670  2712 
 
 13671  256 
                         stream_pathEltOrInverse.add(pathEltOrInverse298.getTree());
 13672   
 
 13673   
                         }
 13674  256 
                         break;
 13675  2712 
 
 13676  2712 
                     default :
 13677  10830 
                         break loop99;
 13678   
                 }
 13679  256 
             } while (true);
 13680  2712 
 
 13681   
 
 13682   
             // AST REWRITE
 13683  5488 
             // elements: pathEltOrInverse
 13684  2776 
             // token labels:
 13685   
             // rule labels: retval
 13686   
             // token list labels:
 13687  2712 
             // rule list labels:
 13688   
             // wildcard labels:
 13689  13542 
             retval.tree = root_0;
 13690  10830 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13691   
 
 13692  10830 
             root_0 = (Object)adaptor.nil();
 13693   
             // 435:48: -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13694   
             {
 13695  2712 
                 // com\\googlecode\\sparkleg\\Sparql.g:435:51: ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13696   
                 {
 13697  10830 
                 Object root_1 = (Object)adaptor.nil();
 13698  10830 
                 root_1 = (Object)adaptor.becomeRoot(
 13699  2712 
                 (Object)adaptor.create(PATH_SEQUENCE, "PATH_SEQUENCE")
 13700   
                 , root_1);
 13701   
 
 13702  13542 
                 if ( !(stream_pathEltOrInverse.hasNext()) ) {
 13703  2712 
                     throw new RewriteEarlyExitException();
 13704   
                 }
 13705  21916 
                 while ( stream_pathEltOrInverse.hasNext() ) {
 13706  11086 
                     adaptor.addChild(root_1, stream_pathEltOrInverse.nextTree());
 13707   
 
 13708   
                 }
 13709  10830 
                 stream_pathEltOrInverse.reset();
 13710   
 
 13711  10830 
                 adaptor.addChild(root_0, root_1);
 13712   
                 }
 13713   
 
 13714   
             }
 13715  2712 
 
 13716  2712 
 
 13717  10830 
             retval.tree = root_0;
 13718   
 
 13719   
             }
 13720   
 
 13721  2776 
             retval.stop = input.LT(-1);
 13722   
 
 13723  2776 
 
 13724  10830 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13725  10830 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13726   
 
 13727   
         }
 13728  0 
         catch (RecognitionException re) {
 13729  0 
             reportError(re);
 13730  2776 
             recover(input,re);
 13731  2776 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13732   
 
 13733   
         }
 13734  2776 
 
 13735  0 
         finally {
 13736  2776 
                 // do for sure before leaving
 13737  13606 
         }
 13738  10830 
         return retval;
 13739   
     }
 13740  2776 
     // $ANTLR end "pathSequence"
 13741   
 
 13742   
 
 13743  11086 
     public static class pathEltOrInverse_return extends ParserRuleReturnScope {
 13744   
         Object tree;
 13745  11086 
         public Object getTree() { return tree; }
 13746  2776 
     };
 13747   
 
 13748   
 
 13749   
     // $ANTLR start "pathEltOrInverse"
 13750  2776 
     // com\\googlecode\\sparkleg\\Sparql.g:438:1: pathEltOrInverse : (i= '^' )? pathElt -> ^( PATH_ELT_OR_INVERSE ( $i)? pathElt ) ;
 13751  2776 
     public final SparqlParser.pathEltOrInverse_return pathEltOrInverse() throws RecognitionException {
 13752  11086 
         SparqlParser.pathEltOrInverse_return retval = new SparqlParser.pathEltOrInverse_return();
 13753  11086 
         retval.start = input.LT(1);
 13754  12 
 
 13755   
 
 13756  11086 
         Object root_0 = null;
 13757   
 
 13758  11086 
         Token i=null;
 13759  13862 
         SparqlParser.pathElt_return pathElt299 =null;
 13760   
 
 13761   
 
 13762  11086 
         Object i_tree=null;
 13763  11098 
         RewriteRuleTokenStream stream_INVERSE=new RewriteRuleTokenStream(adaptor,"token INVERSE");
 13764  11098 
         RewriteRuleSubtreeStream stream_pathElt=new RewriteRuleSubtreeStream(adaptor,"rule pathElt");
 13765   
         try {
 13766   
             // com\\googlecode\\sparkleg\\Sparql.g:439:5: ( (i= '^' )? pathElt -> ^( PATH_ELT_OR_INVERSE ( $i)? pathElt ) )
 13767  12 
             // com\\googlecode\\sparkleg\\Sparql.g:439:7: (i= '^' )? pathElt
 13768   
             {
 13769   
             // com\\googlecode\\sparkleg\\Sparql.g:439:7: (i= '^' )?
 13770  11086 
             int alt100=2;
 13771  11086 
             switch ( input.LA(1) ) {
 13772   
                 case INVERSE:
 13773   
                     {
 13774  48 
                     alt100=1;
 13775   
                     }
 13776  2776 
                     break;
 13777  2776 
             }
 13778   
 
 13779  13862 
             switch (alt100) {
 13780   
                 case 1 :
 13781  2776 
                     // com\\googlecode\\sparkleg\\Sparql.g:439:8: i= '^'
 13782   
                     {
 13783  48 
                     i=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathEltOrInverse3518);
 13784  48 
                     stream_INVERSE.add(i);
 13785  2776 
 
 13786   
 
 13787   
                     }
 13788  2776 
                     break;
 13789  2776 
 
 13790   
             }
 13791   
 
 13792   
 
 13793  11086 
             pushFollow(FOLLOW_pathElt_in_pathEltOrInverse3522);
 13794  11086 
             pathElt299=pathElt();
 13795   
 
 13796  11086 
             state._fsp--;
 13797   
 
 13798  11086 
             stream_pathElt.add(pathElt299.getTree());
 13799   
 
 13800   
             // AST REWRITE
 13801  2776 
             // elements: i, pathElt
 13802  2776 
             // token labels: i
 13803   
             // rule labels: retval
 13804   
             // token list labels:
 13805   
             // rule list labels:
 13806   
             // wildcard labels:
 13807  11086 
             retval.tree = root_0;
 13808  11086 
             RewriteRuleTokenStream stream_i=new RewriteRuleTokenStream(adaptor,"token i",i);
 13809  11086 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13810   
 
 13811  11086 
             root_0 = (Object)adaptor.nil();
 13812   
             // 439:24: -> ^( PATH_ELT_OR_INVERSE ( $i)? pathElt )
 13813   
             {
 13814   
                 // com\\googlecode\\sparkleg\\Sparql.g:439:27: ^( PATH_ELT_OR_INVERSE ( $i)? pathElt )
 13815   
                 {
 13816  13862 
                 Object root_1 = (Object)adaptor.nil();
 13817  13862 
                 root_1 = (Object)adaptor.becomeRoot(
 13818   
                 (Object)adaptor.create(PATH_ELT_OR_INVERSE, "PATH_ELT_OR_INVERSE")
 13819   
                 , root_1);
 13820  2776 
 
 13821   
                 // com\\googlecode\\sparkleg\\Sparql.g:439:50: ( $i)?
 13822  13862 
                 if ( stream_i.hasNext() ) {
 13823  48 
                     adaptor.addChild(root_1, stream_i.nextNode());
 13824  2776 
 
 13825   
                 }
 13826  11086 
                 stream_i.reset();
 13827   
 
 13828  11086 
                 adaptor.addChild(root_1, stream_pathElt.nextTree());
 13829   
 
 13830  11086 
                 adaptor.addChild(root_0, root_1);
 13831   
                 }
 13832  2776 
 
 13833   
             }
 13834   
 
 13835  2776 
 
 13836  13862 
             retval.tree = root_0;
 13837   
 
 13838  2776 
             }
 13839   
 
 13840  13862 
             retval.stop = input.LT(-1);
 13841   
 
 13842   
 
 13843  13862 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13844  13862 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13845   
 
 13846   
         }
 13847  0 
         catch (RecognitionException re) {
 13848  0 
             reportError(re);
 13849  0 
             recover(input,re);
 13850  66 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13851   
 
 13852   
         }
 13853   
 
 13854  0 
         finally {
 13855  2776 
                 // do for sure before leaving
 13856  11086 
         }
 13857  11086 
         return retval;
 13858   
     }
 13859  66 
     // $ANTLR end "pathEltOrInverse"
 13860  66 
 
 13861   
 
 13862  66 
     public static class pathElt_return extends ParserRuleReturnScope {
 13863   
         Object tree;
 13864  66 
         public Object getTree() { return tree; }
 13865   
     };
 13866   
 
 13867   
 
 13868   
     // $ANTLR start "pathElt"
 13869   
     // com\\googlecode\\sparkleg\\Sparql.g:442:1: pathElt : pathPrimary ( pathMod )? ;
 13870   
     public final SparqlParser.pathElt_return pathElt() throws RecognitionException {
 13871  11086 
         SparqlParser.pathElt_return retval = new SparqlParser.pathElt_return();
 13872  11086 
         retval.start = input.LT(1);
 13873   
 
 13874  2776 
 
 13875  11086 
         Object root_0 = null;
 13876   
 
 13877  13862 
         SparqlParser.pathPrimary_return pathPrimary300 =null;
 13878  2776 
 
 13879  11086 
         SparqlParser.pathMod_return pathMod301 =null;
 13880   
 
 13881   
 
 13882   
 
 13883   
         try {
 13884   
             // com\\googlecode\\sparkleg\\Sparql.g:443:5: ( pathPrimary ( pathMod )? )
 13885   
             // com\\googlecode\\sparkleg\\Sparql.g:443:7: pathPrimary ( pathMod )?
 13886   
             {
 13887  11086 
             root_0 = (Object)adaptor.nil();
 13888   
 
 13889   
 
 13890  13862 
             pushFollow(FOLLOW_pathPrimary_in_pathElt3562);
 13891  13862 
             pathPrimary300=pathPrimary();
 13892   
 
 13893  11086 
             state._fsp--;
 13894   
 
 13895  11086 
             adaptor.addChild(root_0, pathPrimary300.getTree());
 13896  66 
 
 13897   
             // com\\googlecode\\sparkleg\\Sparql.g:443:19: ( pathMod )?
 13898  11086 
             int alt101=2;
 13899  11086 
             switch ( input.LA(1) ) {
 13900   
                 case ASTERISK:
 13901   
                 case PLUS:
 13902   
                 case QUESTION_MARK:
 13903   
                 case 216:
 13904   
                     {
 13905  330 
                     alt101=1;
 13906  66 
                     }
 13907   
                     break;
 13908   
             }
 13909  66 
 
 13910  11086 
             switch (alt101) {
 13911  66 
                 case 1 :
 13912  66 
                     // com\\googlecode\\sparkleg\\Sparql.g:443:19: pathMod
 13913  66 
                     {
 13914  330 
                     pushFollow(FOLLOW_pathMod_in_pathElt3564);
 13915  330 
                     pathMod301=pathMod();
 13916  66 
 
 13917  330 
                     state._fsp--;
 13918  66 
 
 13919  330 
                     adaptor.addChild(root_0, pathMod301.getTree());
 13920  66 
 
 13921  66 
                     }
 13922  66 
                     break;
 13923  66 
 
 13924   
             }
 13925  66 
 
 13926  66 
 
 13927  66 
             }
 13928  66 
 
 13929  11152 
             retval.stop = input.LT(-1);
 13930  66 
 
 13931  66 
 
 13932  11152 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13933  11152 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13934  66 
 
 13935  66 
         }
 13936  66 
         catch (RecognitionException re) {
 13937  66 
             reportError(re);
 13938  0 
             recover(input,re);
 13939  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13940   
 
 13941   
         }
 13942   
 
 13943  66 
         finally {
 13944   
                 // do for sure before leaving
 13945  11086 
         }
 13946  11086 
         return retval;
 13947  66 
     }
 13948  66 
     // $ANTLR end "pathElt"
 13949   
 
 13950   
 
 13951  18 
     public static class pathMod_return extends ParserRuleReturnScope {
 13952   
         Object tree;
 13953  18 
         public Object getTree() { return tree; }
 13954   
     };
 13955   
 
 13956  2 
 
 13957   
     // $ANTLR start "pathMod"
 13958  2 
     // com\\googlecode\\sparkleg\\Sparql.g:446:1: pathMod : ( '*' -> PATH_MOD '*' | '?' -> PATH_MOD '?' | '+' -> PATH_MOD '+' | '{' i1= INTEGER '}' -> PATH_MOD $i1| '{' i1= INTEGER c= ',' '}' -> PATH_MOD $i1 $c| '{' i1= INTEGER ',' i2= INTEGER '}' -> PATH_MOD $i1 $i2| '{' c= ',' i2= INTEGER '}' -> PATH_MOD $c $i2);
 13959   
     public final SparqlParser.pathMod_return pathMod() throws RecognitionException {
 13960  264 
         SparqlParser.pathMod_return retval = new SparqlParser.pathMod_return();
 13961  280 
         retval.start = input.LT(1);
 13962   
 
 13963  16 
 
 13964  264 
         Object root_0 = null;
 13965   
 
 13966  294 
         Token i1=null;
 13967  264 
         Token c=null;
 13968  294 
         Token i2=null;
 13969  264 
         Token char_literal302=null;
 13970  264 
         Token char_literal303=null;
 13971  264 
         Token char_literal304=null;
 13972  264 
         Token char_literal305=null;
 13973  264 
         Token char_literal306=null;
 13974  264 
         Token char_literal307=null;
 13975  264 
         Token char_literal308=null;
 13976  264 
         Token char_literal309=null;
 13977  330 
         Token char_literal310=null;
 13978  264 
         Token char_literal311=null;
 13979  264 
         Token char_literal312=null;
 13980  264 
         Token char_literal313=null;
 13981  18 
 
 13982  282 
         Object i1_tree=null;
 13983  264 
         Object c_tree=null;
 13984  264 
         Object i2_tree=null;
 13985  282 
         Object char_literal302_tree=null;
 13986  264 
         Object char_literal303_tree=null;
 13987  264 
         Object char_literal304_tree=null;
 13988  264 
         Object char_literal305_tree=null;
 13989  282 
         Object char_literal306_tree=null;
 13990  264 
         Object char_literal307_tree=null;
 13991  264 
         Object char_literal308_tree=null;
 13992  264 
         Object char_literal309_tree=null;
 13993  266 
         Object char_literal310_tree=null;
 13994  266 
         Object char_literal311_tree=null;
 13995  264 
         Object char_literal312_tree=null;
 13996  264 
         Object char_literal313_tree=null;
 13997  266 
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 13998  264 
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 13999  264 
         RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
 14000  264 
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 14001  266 
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 14002  264 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 14003  264 
         RewriteRuleTokenStream stream_QUESTION_MARK=new RewriteRuleTokenStream(adaptor,"token QUESTION_MARK");
 14004   
 
 14005  16 
         try {
 14006  16 
             // com\\googlecode\\sparkleg\\Sparql.g:447:5: ( '*' -> PATH_MOD '*' | '?' -> PATH_MOD '?' | '+' -> PATH_MOD '+' | '{' i1= INTEGER '}' -> PATH_MOD $i1| '{' i1= INTEGER c= ',' '}' -> PATH_MOD $i1 $c| '{' i1= INTEGER ',' i2= INTEGER '}' -> PATH_MOD $i1 $i2| '{' c= ',' i2= INTEGER '}' -> PATH_MOD $c $i2)
 14007  264 
             int alt102=7;
 14008  264 
             switch ( input.LA(1) ) {
 14009  16 
             case ASTERISK:
 14010   
                 {
 14011  72 
                 alt102=1;
 14012   
                 }
 14013  88 
                 break;
 14014   
             case QUESTION_MARK:
 14015   
                 {
 14016  8 
                 alt102=2;
 14017  30 
                 }
 14018  38 
                 break;
 14019   
             case PLUS:
 14020   
                 {
 14021  94 
                 alt102=3;
 14022   
                 }
 14023  64 
                 break;
 14024   
             case 216:
 14025  30 
                 {
 14026  150 
                 switch ( input.LA(2) ) {
 14027   
                 case INTEGER:
 14028   
                     {
 14029  140 
                     switch ( input.LA(3) ) {
 14030   
                     case 218:
 14031  28 
                         {
 14032  72 
                         alt102=4;
 14033   
                         }
 14034  74 
                         break;
 14035   
                     case 211:
 14036  2 
                         {
 14037  40 
                         switch ( input.LA(4) ) {
 14038   
                         case 218:
 14039   
                             {
 14040  24 
                             alt102=5;
 14041   
                             }
 14042  24 
                             break;
 14043   
                         case INTEGER:
 14044   
                             {
 14045  46 
                             alt102=6;
 14046   
                             }
 14047  16 
                             break;
 14048   
                         default:
 14049  28 
                             NoViableAltException nvae =
 14050  28 
                                 new NoViableAltException("", 102, 8, input);
 14051   
 
 14052  0 
                             throw nvae;
 14053  28 
 
 14054   
                         }
 14055   
 
 14056   
                         }
 14057  68 
                         break;
 14058  28 
                     default:
 14059  0 
                         NoViableAltException nvae =
 14060   
                             new NoViableAltException("", 102, 5, input);
 14061  10 
 
 14062  0 
                         throw nvae;
 14063  10 
 
 14064   
                     }
 14065   
 
 14066  18 
                     }
 14067  112 
                     break;
 14068  18 
                 case 211:
 14069   
                     {
 14070  8 
                     alt102=7;
 14071   
                     }
 14072  8 
                     break;
 14073   
                 default:
 14074  0 
                     NoViableAltException nvae =
 14075   
                         new NoViableAltException("", 102, 4, input);
 14076   
 
 14077  28 
                     throw nvae;
 14078   
 
 14079   
                 }
 14080   
 
 14081  10 
                 }
 14082  130 
                 break;
 14083   
             default:
 14084  0 
                 NoViableAltException nvae =
 14085  10 
                     new NoViableAltException("", 102, 0, input);
 14086   
 
 14087  0 
                 throw nvae;
 14088   
 
 14089  10 
             }
 14090  10 
 
 14091  264 
             switch (alt102) {
 14092   
                 case 1 :
 14093  6 
                     // com\\googlecode\\sparkleg\\Sparql.g:447:7: '*'
 14094   
                     {
 14095  78 
                     char_literal302=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_pathMod3582);
 14096  72 
                     stream_ASTERISK.add(char_literal302);
 14097   
 
 14098  4 
 
 14099   
                     // AST REWRITE
 14100  4 
                     // elements: ASTERISK
 14101   
                     // token labels:
 14102   
                     // rule labels: retval
 14103   
                     // token list labels:
 14104   
                     // rule list labels:
 14105   
                     // wildcard labels:
 14106  72 
                     retval.tree = root_0;
 14107  72 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14108   
 
 14109  82 
                     root_0 = (Object)adaptor.nil();
 14110   
                     // 447:11: -> PATH_MOD '*'
 14111   
                     {
 14112  72 
                         adaptor.addChild(root_0,
 14113  6 
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14114  6 
                         );
 14115   
 
 14116  72 
                         adaptor.addChild(root_0,
 14117  6 
                         stream_ASTERISK.nextNode()
 14118   
                         );
 14119   
 
 14120   
                     }
 14121  6 
 
 14122   
 
 14123  72 
                     retval.tree = root_0;
 14124   
 
 14125  4 
                     }
 14126  76 
                     break;
 14127   
                 case 2 :
 14128   
                     // com\\googlecode\\sparkleg\\Sparql.g:448:7: '?'
 14129  4 
                     {
 14130  8 
                     char_literal303=(Token)match(input,QUESTION_MARK,FOLLOW_QUESTION_MARK_in_pathMod3596);
 14131  8 
                     stream_QUESTION_MARK.add(char_literal303);
 14132  4 
 
 14133  4 
 
 14134   
                     // AST REWRITE
 14135   
                     // elements: QUESTION_MARK
 14136  4 
                     // token labels:
 14137   
                     // rule labels: retval
 14138   
                     // token list labels:
 14139   
                     // rule list labels:
 14140   
                     // wildcard labels:
 14141  8 
                     retval.tree = root_0;
 14142  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14143   
 
 14144  8 
                     root_0 = (Object)adaptor.nil();
 14145   
                     // 448:11: -> PATH_MOD '?'
 14146  10 
                     {
 14147  8 
                         adaptor.addChild(root_0,
 14148   
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14149   
                         );
 14150  18 
 
 14151  26 
                         adaptor.addChild(root_0,
 14152   
                         stream_QUESTION_MARK.nextNode()
 14153   
                         );
 14154  18 
 
 14155   
                     }
 14156   
 
 14157   
 
 14158  8 
                     retval.tree = root_0;
 14159   
 
 14160   
                     }
 14161  8 
                     break;
 14162   
                 case 3 :
 14163   
                     // com\\googlecode\\sparkleg\\Sparql.g:449:7: '+'
 14164  28 
                     {
 14165  64 
                     char_literal304=(Token)match(input,PLUS,FOLLOW_PLUS_in_pathMod3611);
 14166  64 
                     stream_PLUS.add(char_literal304);
 14167   
 
 14168  2 
 
 14169  2 
                     // AST REWRITE
 14170   
                     // elements: PLUS
 14171   
                     // token labels:
 14172  2 
                     // rule labels: retval
 14173   
                     // token list labels:
 14174   
                     // rule list labels:
 14175  2 
                     // wildcard labels:
 14176  66 
                     retval.tree = root_0;
 14177  64 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14178   
 
 14179  66 
                     root_0 = (Object)adaptor.nil();
 14180   
                     // 449:11: -> PATH_MOD '+'
 14181   
                     {
 14182  66 
                         adaptor.addChild(root_0,
 14183  2 
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14184   
                         );
 14185   
 
 14186  66 
                         adaptor.addChild(root_0,
 14187   
                         stream_PLUS.nextNode()
 14188   
                         );
 14189   
 
 14190   
                     }
 14191   
 
 14192   
 
 14193  64 
                     retval.tree = root_0;
 14194   
 
 14195   
                     }
 14196  64 
                     break;
 14197   
                 case 4 :
 14198   
                     // com\\googlecode\\sparkleg\\Sparql.g:450:7: '{' i1= INTEGER '}'
 14199   
                     {
 14200  72 
                     char_literal305=(Token)match(input,216,FOLLOW_216_in_pathMod3626);
 14201  72 
                     stream_216.add(char_literal305);
 14202   
 
 14203  66 
 
 14204  72 
                     i1=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3630);
 14205  72 
                     stream_INTEGER.add(i1);
 14206  66 
 
 14207  66 
 
 14208  72 
                     char_literal306=(Token)match(input,218,FOLLOW_218_in_pathMod3632);
 14209  72 
                     stream_218.add(char_literal306);
 14210   
 
 14211   
 
 14212   
                     // AST REWRITE
 14213   
                     // elements: i1
 14214   
                     // token labels: i1
 14215   
                     // rule labels: retval
 14216   
                     // token list labels:
 14217   
                     // rule list labels:
 14218   
                     // wildcard labels:
 14219  138 
                     retval.tree = root_0;
 14220  138 
                     RewriteRuleTokenStream stream_i1=new RewriteRuleTokenStream(adaptor,"token i1",i1);
 14221  72 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14222   
 
 14223  72 
                     root_0 = (Object)adaptor.nil();
 14224   
                     // 450:26: -> PATH_MOD $i1
 14225  2776 
                     {
 14226  72 
                         adaptor.addChild(root_0,
 14227  2776 
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14228   
                         );
 14229   
 
 14230  72 
                         adaptor.addChild(root_0, stream_i1.nextNode());
 14231   
 
 14232   
                     }
 14233   
 
 14234  2776 
 
 14235  2848 
                     retval.tree = root_0;
 14236   
 
 14237   
                     }
 14238  2848 
                     break;
 14239   
                 case 5 :
 14240  2776 
                     // com\\googlecode\\sparkleg\\Sparql.g:451:7: '{' i1= INTEGER c= ',' '}'
 14241  2776 
                     {
 14242  2800 
                     char_literal307=(Token)match(input,216,FOLLOW_216_in_pathMod3647);
 14243  2800 
                     stream_216.add(char_literal307);
 14244  2776 
 
 14245   
 
 14246  2800 
                     i1=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3651);
 14247  24 
                     stream_INTEGER.add(i1);
 14248  2776 
 
 14249   
 
 14250  24 
                     c=(Token)match(input,211,FOLLOW_211_in_pathMod3655);
 14251  2800 
                     stream_211.add(c);
 14252  2776 
 
 14253  2776 
 
 14254  2800 
                     char_literal308=(Token)match(input,218,FOLLOW_218_in_pathMod3657);
 14255  2800 
                     stream_218.add(char_literal308);
 14256  2776 
 
 14257  2776 
 
 14258  2776 
                     // AST REWRITE
 14259  2776 
                     // elements: c, i1
 14260  2776 
                     // token labels: c, i1
 14261  2776 
                     // rule labels: retval
 14262   
                     // token list labels:
 14263   
                     // rule list labels:
 14264  2776 
                     // wildcard labels:
 14265  2800 
                     retval.tree = root_0;
 14266  24 
                     RewriteRuleTokenStream stream_c=new RewriteRuleTokenStream(adaptor,"token c",c);
 14267  24 
                     RewriteRuleTokenStream stream_i1=new RewriteRuleTokenStream(adaptor,"token i1",i1);
 14268  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14269   
 
 14270  2710 
                     root_0 = (Object)adaptor.nil();
 14271   
                     // 451:32: -> PATH_MOD $i1 $c
 14272  2686 
                     {
 14273  24 
                         adaptor.addChild(root_0,
 14274   
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14275  64 
                         );
 14276   
 
 14277  88 
                         adaptor.addChild(root_0, stream_i1.nextNode());
 14278   
 
 14279  24 
                         adaptor.addChild(root_0, stream_c.nextNode());
 14280  6 
 
 14281   
                     }
 14282  6 
 
 14283   
 
 14284  24 
                     retval.tree = root_0;
 14285  20 
 
 14286   
                     }
 14287  44 
                     break;
 14288   
                 case 6 :
 14289   
                     // com\\googlecode\\sparkleg\\Sparql.g:452:7: '{' i1= INTEGER ',' i2= INTEGER '}'
 14290   
                     {
 14291  16 
                     char_literal309=(Token)match(input,216,FOLLOW_216_in_pathMod3675);
 14292  16 
                     stream_216.add(char_literal309);
 14293   
 
 14294   
 
 14295  16 
                     i1=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3679);
 14296  2792 
                     stream_INTEGER.add(i1);
 14297   
 
 14298   
 
 14299  16 
                     char_literal310=(Token)match(input,211,FOLLOW_211_in_pathMod3681);
 14300  2702 
                     stream_211.add(char_literal310);
 14301  2686 
 
 14302   
 
 14303  2702 
                     i2=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3685);
 14304  16 
                     stream_INTEGER.add(i2);
 14305  2686 
 
 14306   
 
 14307  16 
                     char_literal311=(Token)match(input,218,FOLLOW_218_in_pathMod3687);
 14308  16 
                     stream_218.add(char_literal311);
 14309   
 
 14310   
 
 14311   
                     // AST REWRITE
 14312   
                     // elements: i1, i2
 14313   
                     // token labels: i2, i1
 14314  2686 
                     // rule labels: retval
 14315  2686 
                     // token list labels:
 14316   
                     // rule list labels:
 14317  2686 
                     // wildcard labels:
 14318  16 
                     retval.tree = root_0;
 14319  16 
                     RewriteRuleTokenStream stream_i2=new RewriteRuleTokenStream(adaptor,"token i2",i2);
 14320  16 
                     RewriteRuleTokenStream stream_i1=new RewriteRuleTokenStream(adaptor,"token i1",i1);
 14321  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14322  2686 
 
 14323  2702 
                     root_0 = (Object)adaptor.nil();
 14324   
                     // 452:42: -> PATH_MOD $i1 $i2
 14325   
                     {
 14326  16 
                         adaptor.addChild(root_0,
 14327  2686 
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14328   
                         );
 14329  2686 
 
 14330  16 
                         adaptor.addChild(root_0, stream_i1.nextNode());
 14331   
 
 14332  16 
                         adaptor.addChild(root_0, stream_i2.nextNode());
 14333   
 
 14334   
                     }
 14335  2686 
 
 14336   
 
 14337  16 
                     retval.tree = root_0;
 14338  2686 
 
 14339   
                     }
 14340  16 
                     break;
 14341   
                 case 7 :
 14342  64 
                     // com\\googlecode\\sparkleg\\Sparql.g:453:7: '{' c= ',' i2= INTEGER '}'
 14343  64 
                     {
 14344  8 
                     char_literal312=(Token)match(input,216,FOLLOW_216_in_pathMod3706);
 14345  8 
                     stream_216.add(char_literal312);
 14346   
 
 14347   
 
 14348  8 
                     c=(Token)match(input,211,FOLLOW_211_in_pathMod3710);
 14349  8 
                     stream_211.add(c);
 14350   
 
 14351   
 
 14352  8 
                     i2=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3714);
 14353  72 
                     stream_INTEGER.add(i2);
 14354  64 
 
 14355   
 
 14356  72 
                     char_literal313=(Token)match(input,218,FOLLOW_218_in_pathMod3716);
 14357  8 
                     stream_218.add(char_literal313);
 14358   
 
 14359   
 
 14360   
                     // AST REWRITE
 14361  64 
                     // elements: c, i2
 14362  64 
                     // token labels: c, i2
 14363   
                     // rule labels: retval
 14364   
                     // token list labels:
 14365   
                     // rule list labels:
 14366  64 
                     // wildcard labels:
 14367  8 
                     retval.tree = root_0;
 14368  8 
                     RewriteRuleTokenStream stream_c=new RewriteRuleTokenStream(adaptor,"token c",c);
 14369  8 
                     RewriteRuleTokenStream stream_i2=new RewriteRuleTokenStream(adaptor,"token i2",i2);
 14370  72 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14371   
 
 14372  8 
                     root_0 = (Object)adaptor.nil();
 14373   
                     // 453:32: -> PATH_MOD $c $i2
 14374   
                     {
 14375  8 
                         adaptor.addChild(root_0,
 14376  64 
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14377   
                         );
 14378   
 
 14379  72 
                         adaptor.addChild(root_0, stream_c.nextNode());
 14380   
 
 14381  8 
                         adaptor.addChild(root_0, stream_i2.nextNode());
 14382   
 
 14383  6 
                     }
 14384  6 
 
 14385   
 
 14386  8 
                     retval.tree = root_0;
 14387  6 
 
 14388  6 
                     }
 14389   
                     break;
 14390  6 
 
 14391   
             }
 14392  270 
             retval.stop = input.LT(-1);
 14393   
 
 14394   
 
 14395  264 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14396  264 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14397   
 
 14398   
         }
 14399  0 
         catch (RecognitionException re) {
 14400  0 
             reportError(re);
 14401  6 
             recover(input,re);
 14402  6 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14403   
 
 14404  6 
         }
 14405   
 
 14406  0 
         finally {
 14407   
                 // do for sure before leaving
 14408  264 
         }
 14409  270 
         return retval;
 14410  6 
     }
 14411   
     // $ANTLR end "pathMod"
 14412   
 
 14413   
 
 14414  6 
     public static class pathPrimary_return extends ParserRuleReturnScope {
 14415   
         Object tree;
 14416  11086 
         public Object getTree() { return tree; }
 14417   
     };
 14418  6 
 
 14419   
 
 14420  6 
     // $ANTLR start "pathPrimary"
 14421   
     // com\\googlecode\\sparkleg\\Sparql.g:456:1: pathPrimary : ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | '!' pathNegatedPropertySet -> ^( PATH_PRIMARY pathNegatedPropertySet ) | '(' path ')' -> ^( PATH_PRIMARY path ) );
 14422   
     public final SparqlParser.pathPrimary_return pathPrimary() throws RecognitionException {
 14423  11086 
         SparqlParser.pathPrimary_return retval = new SparqlParser.pathPrimary_return();
 14424  11086 
         retval.start = input.LT(1);
 14425   
 
 14426  6 
 
 14427  11086 
         Object root_0 = null;
 14428   
 
 14429  11092 
         Token A315=null;
 14430  11086 
         Token char_literal316=null;
 14431  11086 
         Token char_literal318=null;
 14432  11086 
         Token char_literal320=null;
 14433  11106 
         SparqlParser.iriRef_return iriRef314 =null;
 14434  20 
 
 14435  11086 
         SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet317 =null;
 14436   
 
 14437  11106 
         SparqlParser.path_return path319 =null;
 14438  20 
 
 14439   
 
 14440  11106 
         Object A315_tree=null;
 14441  11086 
         Object char_literal316_tree=null;
 14442  11106 
         Object char_literal318_tree=null;
 14443  11086 
         Object char_literal320_tree=null;
 14444  11106 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 14445  11106 
         RewriteRuleTokenStream stream_A=new RewriteRuleTokenStream(adaptor,"token A");
 14446  11086 
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 14447  11086 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 14448  11086 
         RewriteRuleSubtreeStream stream_path=new RewriteRuleSubtreeStream(adaptor,"rule path");
 14449  11086 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 14450  11086 
         RewriteRuleSubtreeStream stream_pathNegatedPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathNegatedPropertySet");
 14451   
         try {
 14452   
             // com\\googlecode\\sparkleg\\Sparql.g:457:5: ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | '!' pathNegatedPropertySet -> ^( PATH_PRIMARY pathNegatedPropertySet ) | '(' path ')' -> ^( PATH_PRIMARY path ) )
 14453  11086 
             int alt103=4;
 14454  11086 
             switch ( input.LA(1) ) {
 14455  20 
             case IRI_REF:
 14456  20 
             case PNAME_LN:
 14457   
             case PNAME_NS:
 14458  20 
                 {
 14459  10726 
                 alt103=1;
 14460   
                 }
 14461  10726 
                 break;
 14462   
             case A:
 14463  20 
                 {
 14464  276 
                 alt103=2;
 14465   
                 }
 14466  256 
                 break;
 14467   
             case NEGATION:
 14468  20 
                 {
 14469  24 
                 alt103=3;
 14470  20 
                 }
 14471  24 
                 break;
 14472   
             case 209:
 14473   
                 {
 14474  80 
                 alt103=4;
 14475   
                 }
 14476  100 
                 break;
 14477   
             default:
 14478  0 
                 NoViableAltException nvae =
 14479   
                     new NoViableAltException("", 103, 0, input);
 14480   
 
 14481  0 
                 throw nvae;
 14482  2776 
 
 14483   
             }
 14484   
 
 14485  13862 
             switch (alt103) {
 14486  2776 
                 case 1 :
 14487   
                     // com\\googlecode\\sparkleg\\Sparql.g:457:7: iriRef
 14488   
                     {
 14489  10726 
                     pushFollow(FOLLOW_iriRef_in_pathPrimary3743);
 14490  10726 
                     iriRef314=iriRef();
 14491   
 
 14492  10726 
                     state._fsp--;
 14493   
 
 14494  10726 
                     stream_iriRef.add(iriRef314.getTree());
 14495   
 
 14496   
                     // AST REWRITE
 14497   
                     // elements: iriRef
 14498  2776 
                     // token labels:
 14499  2776 
                     // rule labels: retval
 14500   
                     // token list labels:
 14501   
                     // rule list labels:
 14502   
                     // wildcard labels:
 14503  10726 
                     retval.tree = root_0;
 14504  10726 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14505   
 
 14506  10726 
                     root_0 = (Object)adaptor.nil();
 14507   
                     // 457:14: -> ^( PATH_PRIMARY iriRef )
 14508   
                     {
 14509   
                         // com\\googlecode\\sparkleg\\Sparql.g:457:17: ^( PATH_PRIMARY iriRef )
 14510   
                         {
 14511  10726 
                         Object root_1 = (Object)adaptor.nil();
 14512  10726 
                         root_1 = (Object)adaptor.becomeRoot(
 14513  6 
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14514  6 
                         , root_1);
 14515   
 
 14516  10726 
                         adaptor.addChild(root_1, stream_iriRef.nextTree());
 14517  6 
 
 14518  10726 
                         adaptor.addChild(root_0, root_1);
 14519  6 
                         }
 14520  6 
 
 14521  6 
                     }
 14522  6 
 
 14523   
 
 14524  10732 
                     retval.tree = root_0;
 14525   
 
 14526  6 
                     }
 14527  10726 
                     break;
 14528   
                 case 2 :
 14529  6 
                     // com\\googlecode\\sparkleg\\Sparql.g:458:7: A
 14530  6 
                     {
 14531  262 
                     A315=(Token)match(input,A,FOLLOW_A_in_pathPrimary3759);
 14532  262 
                     stream_A.add(A315);
 14533  6 
 
 14534  6 
 
 14535  6 
                     // AST REWRITE
 14536   
                     // elements: A
 14537   
                     // token labels:
 14538  6 
                     // rule labels: retval
 14539  6 
                     // token list labels:
 14540   
                     // rule list labels:
 14541   
                     // wildcard labels:
 14542  256 
                     retval.tree = root_0;
 14543  256 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14544   
 
 14545  256 
                     root_0 = (Object)adaptor.nil();
 14546   
                     // 458:9: -> ^( PATH_PRIMARY A )
 14547   
                     {
 14548   
                         // com\\googlecode\\sparkleg\\Sparql.g:458:12: ^( PATH_PRIMARY A )
 14549   
                         {
 14550  256 
                         Object root_1 = (Object)adaptor.nil();
 14551  262 
                         root_1 = (Object)adaptor.becomeRoot(
 14552   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14553  6 
                         , root_1);
 14554   
 
 14555  256 
                         adaptor.addChild(root_1,
 14556   
                         stream_A.nextNode()
 14557   
                         );
 14558   
 
 14559  256 
                         adaptor.addChild(root_0, root_1);
 14560   
                         }
 14561   
 
 14562  6 
                     }
 14563   
 
 14564   
 
 14565  256 
                     retval.tree = root_0;
 14566   
 
 14567   
                     }
 14568  256 
                     break;
 14569   
                 case 3 :
 14570   
                     // com\\googlecode\\sparkleg\\Sparql.g:459:7: '!' pathNegatedPropertySet
 14571   
                     {
 14572  24 
                     char_literal316=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_pathPrimary3775);
 14573  24 
                     stream_NEGATION.add(char_literal316);
 14574   
 
 14575   
 
 14576  24 
                     pushFollow(FOLLOW_pathNegatedPropertySet_in_pathPrimary3777);
 14577  24 
                     pathNegatedPropertySet317=pathNegatedPropertySet();
 14578   
 
 14579  24 
                     state._fsp--;
 14580   
 
 14581  24 
                     stream_pathNegatedPropertySet.add(pathNegatedPropertySet317.getTree());
 14582   
 
 14583   
                     // AST REWRITE
 14584   
                     // elements: pathNegatedPropertySet
 14585   
                     // token labels:
 14586   
                     // rule labels: retval
 14587   
                     // token list labels:
 14588   
                     // rule list labels:
 14589   
                     // wildcard labels:
 14590  24 
                     retval.tree = root_0;
 14591  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14592   
 
 14593  24 
                     root_0 = (Object)adaptor.nil();
 14594   
                     // 459:34: -> ^( PATH_PRIMARY pathNegatedPropertySet )
 14595   
                     {
 14596   
                         // com\\googlecode\\sparkleg\\Sparql.g:459:37: ^( PATH_PRIMARY pathNegatedPropertySet )
 14597   
                         {
 14598  24 
                         Object root_1 = (Object)adaptor.nil();
 14599  24 
                         root_1 = (Object)adaptor.becomeRoot(
 14600   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14601   
                         , root_1);
 14602   
 
 14603  24 
                         adaptor.addChild(root_1, stream_pathNegatedPropertySet.nextTree());
 14604   
 
 14605  24 
                         adaptor.addChild(root_0, root_1);
 14606   
                         }
 14607   
 
 14608  6 
                     }
 14609  6 
 
 14610   
 
 14611  24 
                     retval.tree = root_0;
 14612   
 
 14613  6 
                     }
 14614  30 
                     break;
 14615   
                 case 4 :
 14616   
                     // com\\googlecode\\sparkleg\\Sparql.g:460:7: '(' path ')'
 14617   
                     {
 14618  80 
                     char_literal318=(Token)match(input,209,FOLLOW_209_in_pathPrimary3793);
 14619  80 
                     stream_209.add(char_literal318);
 14620   
 
 14621  6 
 
 14622  80 
                     pushFollow(FOLLOW_path_in_pathPrimary3795);
 14623  80 
                     path319=path();
 14624   
 
 14625  80 
                     state._fsp--;
 14626  6 
 
 14627  80 
                     stream_path.add(path319.getTree());
 14628   
 
 14629  80 
                     char_literal320=(Token)match(input,210,FOLLOW_210_in_pathPrimary3797);
 14630  86 
                     stream_210.add(char_literal320);
 14631  6 
 
 14632   
 
 14633  6 
                     // AST REWRITE
 14634   
                     // elements: path
 14635  6 
                     // token labels:
 14636   
                     // rule labels: retval
 14637   
                     // token list labels:
 14638   
                     // rule list labels:
 14639   
                     // wildcard labels:
 14640  92 
                     retval.tree = root_0;
 14641  92 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14642   
 
 14643  80 
                     root_0 = (Object)adaptor.nil();
 14644  6 
                     // 460:20: -> ^( PATH_PRIMARY path )
 14645   
                     {
 14646   
                         // com\\googlecode\\sparkleg\\Sparql.g:460:23: ^( PATH_PRIMARY path )
 14647   
                         {
 14648  80 
                         Object root_1 = (Object)adaptor.nil();
 14649  80 
                         root_1 = (Object)adaptor.becomeRoot(
 14650  12 
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14651   
                         , root_1);
 14652   
 
 14653  80 
                         adaptor.addChild(root_1, stream_path.nextTree());
 14654  6 
 
 14655  86 
                         adaptor.addChild(root_0, root_1);
 14656   
                         }
 14657   
 
 14658  6 
                     }
 14659  6 
 
 14660   
 
 14661  86 
                     retval.tree = root_0;
 14662   
 
 14663  6 
                     }
 14664   
                     break;
 14665   
 
 14666  6 
             }
 14667  11086 
             retval.stop = input.LT(-1);
 14668   
 
 14669  6 
 
 14670  11086 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14671  11092 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14672   
 
 14673   
         }
 14674  0 
         catch (RecognitionException re) {
 14675  0 
             reportError(re);
 14676  0 
             recover(input,re);
 14677  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14678   
 
 14679   
         }
 14680  6 
 
 14681  6 
         finally {
 14682   
                 // do for sure before leaving
 14683  11086 
         }
 14684  11086 
         return retval;
 14685   
     }
 14686   
     // $ANTLR end "pathPrimary"
 14687   
 
 14688   
 
 14689  24 
     public static class pathNegatedPropertySet_return extends ParserRuleReturnScope {
 14690   
         Object tree;
 14691  6 
         public Object getTree() { return tree; }
 14692  6 
     };
 14693   
 
 14694  6 
 
 14695   
     // $ANTLR start "pathNegatedPropertySet"
 14696   
     // com\\googlecode\\sparkleg\\Sparql.g:463:1: pathNegatedPropertySet : ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | '(' ( pathOneInPropertySet ( '|' pathOneInPropertySet )* )? ')' -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) );
 14697   
     public final SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet() throws RecognitionException {
 14698  24 
         SparqlParser.pathNegatedPropertySet_return retval = new SparqlParser.pathNegatedPropertySet_return();
 14699  30 
         retval.start = input.LT(1);
 14700  6 
 
 14701   
 
 14702  24 
         Object root_0 = null;
 14703   
 
 14704  30 
         Token char_literal322=null;
 14705  24 
         Token char_literal324=null;
 14706  24 
         Token char_literal326=null;
 14707  42 
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet321 =null;
 14708  12 
 
 14709  24 
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet323 =null;
 14710   
 
 14711  30 
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet325 =null;
 14712   
 
 14713  6 
 
 14714  24 
         Object char_literal322_tree=null;
 14715  24 
         Object char_literal324_tree=null;
 14716  24 
         Object char_literal326_tree=null;
 14717  24 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 14718  24 
         RewriteRuleTokenStream stream_217=new RewriteRuleTokenStream(adaptor,"token 217");
 14719  30 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 14720  24 
         RewriteRuleSubtreeStream stream_pathOneInPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathOneInPropertySet");
 14721   
         try {
 14722   
             // com\\googlecode\\sparkleg\\Sparql.g:464:5: ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | '(' ( pathOneInPropertySet ( '|' pathOneInPropertySet )* )? ')' -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) )
 14723  24 
             int alt106=2;
 14724  24 
             switch ( input.LA(1) ) {
 14725  6 
             case A:
 14726   
             case INVERSE:
 14727   
             case IRI_REF:
 14728  6 
             case PNAME_LN:
 14729  6 
             case PNAME_NS:
 14730   
                 {
 14731  0 
                 alt106=1;
 14732   
                 }
 14733  0 
                 break;
 14734   
             case 209:
 14735   
                 {
 14736  24 
                 alt106=2;
 14737   
                 }
 14738  24 
                 break;
 14739   
             default:
 14740  0 
                 NoViableAltException nvae =
 14741  6 
                     new NoViableAltException("", 106, 0, input);
 14742  6 
 
 14743  0 
                 throw nvae;
 14744   
 
 14745   
             }
 14746   
 
 14747  24 
             switch (alt106) {
 14748   
                 case 1 :
 14749  12 
                     // com\\googlecode\\sparkleg\\Sparql.g:464:7: pathOneInPropertySet
 14750   
                     {
 14751  0 
                     pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3822);
 14752  0 
                     pathOneInPropertySet321=pathOneInPropertySet();
 14753   
 
 14754  0 
                     state._fsp--;
 14755   
 
 14756  12 
                     stream_pathOneInPropertySet.add(pathOneInPropertySet321.getTree());
 14757  12 
 
 14758   
                     // AST REWRITE
 14759   
                     // elements: pathOneInPropertySet
 14760  12 
                     // token labels:
 14761   
                     // rule labels: retval
 14762  12 
                     // token list labels:
 14763  12 
                     // rule list labels:
 14764  12 
                     // wildcard labels:
 14765  0 
                     retval.tree = root_0;
 14766  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14767  12 
 
 14768  12 
                     root_0 = (Object)adaptor.nil();
 14769   
                     // 464:28: -> ^( PATH_NEGATED pathOneInPropertySet )
 14770   
                     {
 14771   
                         // com\\googlecode\\sparkleg\\Sparql.g:464:31: ^( PATH_NEGATED pathOneInPropertySet )
 14772   
                         {
 14773  0 
                         Object root_1 = (Object)adaptor.nil();
 14774  12 
                         root_1 = (Object)adaptor.becomeRoot(
 14775   
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14776   
                         , root_1);
 14777   
 
 14778  12 
                         adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14779  12 
 
 14780  0 
                         adaptor.addChild(root_0, root_1);
 14781   
                         }
 14782  4 
 
 14783   
                     }
 14784   
 
 14785   
 
 14786  0 
                     retval.tree = root_0;
 14787  12 
 
 14788   
                     }
 14789  0 
                     break;
 14790   
                 case 2 :
 14791  4 
                     // com\\googlecode\\sparkleg\\Sparql.g:465:7: '(' ( pathOneInPropertySet ( '|' pathOneInPropertySet )* )? ')'
 14792  4 
                     {
 14793  24 
                     char_literal322=(Token)match(input,209,FOLLOW_209_in_pathNegatedPropertySet3838);
 14794  24 
                     stream_209.add(char_literal322);
 14795  4 
 
 14796   
 
 14797   
                     // com\\googlecode\\sparkleg\\Sparql.g:465:11: ( pathOneInPropertySet ( '|' pathOneInPropertySet )* )?
 14798  24 
                     int alt105=2;
 14799  24 
                     switch ( input.LA(1) ) {
 14800   
                         case A:
 14801   
                         case INVERSE:
 14802   
                         case IRI_REF:
 14803   
                         case PNAME_LN:
 14804   
                         case PNAME_NS:
 14805  12 
                             {
 14806  36 
                             alt105=1;
 14807   
                             }
 14808   
                             break;
 14809   
                     }
 14810   
 
 14811  36 
                     switch (alt105) {
 14812   
                         case 1 :
 14813  12 
                             // com\\googlecode\\sparkleg\\Sparql.g:465:12: pathOneInPropertySet ( '|' pathOneInPropertySet )*
 14814   
                             {
 14815  24 
                             pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3841);
 14816  24 
                             pathOneInPropertySet323=pathOneInPropertySet();
 14817   
 
 14818  24 
                             state._fsp--;
 14819   
 
 14820  24 
                             stream_pathOneInPropertySet.add(pathOneInPropertySet323.getTree());
 14821   
 
 14822   
                             // com\\googlecode\\sparkleg\\Sparql.g:465:33: ( '|' pathOneInPropertySet )*
 14823   
                             loop104:
 14824   
                             do {
 14825  48 
                                 int alt104=2;
 14826  48 
                                 switch ( input.LA(1) ) {
 14827  12 
                                 case 217:
 14828   
                                     {
 14829  24 
                                     alt104=1;
 14830   
                                     }
 14831  12 
                                     break;
 14832  12 
 
 14833   
                                 }
 14834  12 
 
 14835  48 
                                 switch (alt104) {
 14836  12 
                                     case 1 :
 14837   
                                         // com\\googlecode\\sparkleg\\Sparql.g:465:34: '|' pathOneInPropertySet
 14838   
                                         {
 14839  36 
                                         char_literal324=(Token)match(input,217,FOLLOW_217_in_pathNegatedPropertySet3844);
 14840  24 
                                         stream_217.add(char_literal324);
 14841   
 
 14842   
 
 14843  24 
                                         pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3846);
 14844  24 
                                         pathOneInPropertySet325=pathOneInPropertySet();
 14845   
 
 14846  24 
                                         state._fsp--;
 14847   
 
 14848  24 
                                         stream_pathOneInPropertySet.add(pathOneInPropertySet325.getTree());
 14849   
 
 14850   
                                         }
 14851  24 
                                         break;
 14852   
 
 14853   
                                     default :
 14854  24 
                                         break loop104;
 14855   
                                 }
 14856  24 
                             } while (true);
 14857   
 
 14858  12 
 
 14859   
                             }
 14860   
                             break;
 14861  12 
 
 14862  12 
                     }
 14863   
 
 14864   
 
 14865  24 
                     char_literal326=(Token)match(input,210,FOLLOW_210_in_pathNegatedPropertySet3852);
 14866  24 
                     stream_210.add(char_literal326);
 14867   
 
 14868   
 
 14869   
                     // AST REWRITE
 14870   
                     // elements: pathOneInPropertySet
 14871   
                     // token labels:
 14872   
                     // rule labels: retval
 14873   
                     // token list labels:
 14874  12 
                     // rule list labels:
 14875  12 
                     // wildcard labels:
 14876  24 
                     retval.tree = root_0;
 14877  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14878   
 
 14879  24 
                     root_0 = (Object)adaptor.nil();
 14880  58 
                     // 465:67: -> ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14881   
                     {
 14882  58 
                         // com\\googlecode\\sparkleg\\Sparql.g:465:70: ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14883   
                         {
 14884  24 
                         Object root_1 = (Object)adaptor.nil();
 14885  24 
                         root_1 = (Object)adaptor.becomeRoot(
 14886   
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14887   
                         , root_1);
 14888   
 
 14889  82 
                         if ( !(stream_pathOneInPropertySet.hasNext()) ) {
 14890  58 
                             throw new RewriteEarlyExitException();
 14891   
                         }
 14892  72 
                         while ( stream_pathOneInPropertySet.hasNext() ) {
 14893  106 
                             adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14894   
 
 14895  58 
                         }
 14896  82 
                         stream_pathOneInPropertySet.reset();
 14897  58 
 
 14898  82 
                         adaptor.addChild(root_0, root_1);
 14899  58 
                         }
 14900   
 
 14901  58 
                     }
 14902   
 
 14903   
 
 14904  82 
                     retval.tree = root_0;
 14905  58 
 
 14906  58 
                     }
 14907  58 
                     break;
 14908  58 
 
 14909  58 
             }
 14910  82 
             retval.stop = input.LT(-1);
 14911  58 
 
 14912  58 
 
 14913  82 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14914  24 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14915   
 
 14916  58 
         }
 14917  58 
         catch (RecognitionException re) {
 14918  0 
             reportError(re);
 14919  0 
             recover(input,re);
 14920  28 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14921   
 
 14922  28 
         }
 14923   
 
 14924  0 
         finally {
 14925  30 
                 // do for sure before leaving
 14926  24 
         }
 14927  54 
         return retval;
 14928   
     }
 14929   
     // $ANTLR end "pathNegatedPropertySet"
 14930   
 
 14931   
 
 14932  48 
     public static class pathOneInPropertySet_return extends ParserRuleReturnScope {
 14933   
         Object tree;
 14934  48 
         public Object getTree() { return tree; }
 14935   
     };
 14936  58 
 
 14937   
 
 14938   
     // $ANTLR start "pathOneInPropertySet"
 14939   
     // com\\googlecode\\sparkleg\\Sparql.g:468:1: pathOneInPropertySet : ( '^' )? ( iriRef | A ) ;
 14940  28 
     public final SparqlParser.pathOneInPropertySet_return pathOneInPropertySet() throws RecognitionException {
 14941  76 
         SparqlParser.pathOneInPropertySet_return retval = new SparqlParser.pathOneInPropertySet_return();
 14942  48 
         retval.start = input.LT(1);
 14943   
 
 14944   
 
 14945  76 
         Object root_0 = null;
 14946   
 
 14947  48 
         Token char_literal327=null;
 14948  114 
         Token A329=null;
 14949  114 
         SparqlParser.iriRef_return iriRef328 =null;
 14950   
 
 14951   
 
 14952  48 
         Object char_literal327_tree=null;
 14953  48 
         Object A329_tree=null;
 14954   
 
 14955   
         try {
 14956   
             // com\\googlecode\\sparkleg\\Sparql.g:469:5: ( ( '^' )? ( iriRef | A ) )
 14957   
             // com\\googlecode\\sparkleg\\Sparql.g:469:7: ( '^' )? ( iriRef | A )
 14958   
             {
 14959  48 
             root_0 = (Object)adaptor.nil();
 14960   
 
 14961   
 
 14962   
             // com\\googlecode\\sparkleg\\Sparql.g:469:7: ( '^' )?
 14963  48 
             int alt107=2;
 14964  48 
             switch ( input.LA(1) ) {
 14965   
                 case INVERSE:
 14966   
                     {
 14967  16 
                     alt107=1;
 14968   
                     }
 14969   
                     break;
 14970   
             }
 14971   
 
 14972  48 
             switch (alt107) {
 14973   
                 case 1 :
 14974  38 
                     // com\\googlecode\\sparkleg\\Sparql.g:469:7: '^'
 14975   
                     {
 14976  16 
                     char_literal327=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathOneInPropertySet3881);
 14977  16 
                     char_literal327_tree =
 14978   
                     (Object)adaptor.create(char_literal327)
 14979   
                     ;
 14980  82 
                     adaptor.addChild(root_0, char_literal327_tree);
 14981   
 
 14982   
 
 14983   
                     }
 14984  38 
                     break;
 14985  38 
 
 14986   
             }
 14987  38 
 
 14988   
 
 14989  38 
             // com\\googlecode\\sparkleg\\Sparql.g:469:12: ( iriRef | A )
 14990  48 
             int alt108=2;
 14991  48 
             switch ( input.LA(1) ) {
 14992  38 
             case IRI_REF:
 14993   
             case PNAME_LN:
 14994   
             case PNAME_NS:
 14995  28 
                 {
 14996  48 
                 alt108=1;
 14997   
                 }
 14998  48 
                 break;
 14999   
             case A:
 15000  38 
                 {
 15001  38 
                 alt108=2;
 15002   
                 }
 15003  0 
                 break;
 15004  28 
             default:
 15005  28 
                 NoViableAltException nvae =
 15006   
                     new NoViableAltException("", 108, 0, input);
 15007   
 
 15008  0 
                 throw nvae;
 15009   
 
 15010   
             }
 15011   
 
 15012  48 
             switch (alt108) {
 15013   
                 case 1 :
 15014   
                     // com\\googlecode\\sparkleg\\Sparql.g:469:13: iriRef
 15015  28 
                     {
 15016  76 
                     pushFollow(FOLLOW_iriRef_in_pathOneInPropertySet3885);
 15017  48 
                     iriRef328=iriRef();
 15018  28 
 
 15019  48 
                     state._fsp--;
 15020   
 
 15021  48 
                     adaptor.addChild(root_0, iriRef328.getTree());
 15022   
 
 15023  28 
                     }
 15024  76 
                     break;
 15025   
                 case 2 :
 15026   
                     // com\\googlecode\\sparkleg\\Sparql.g:469:22: A
 15027   
                     {
 15028  28 
                     A329=(Token)match(input,A,FOLLOW_A_in_pathOneInPropertySet3889);
 15029  0 
                     A329_tree =
 15030   
                     (Object)adaptor.create(A329)
 15031  66 
                     ;
 15032  38 
                     adaptor.addChild(root_0, A329_tree);
 15033   
 
 15034   
 
 15035  28 
                     }
 15036   
                     break;
 15037  28 
 
 15038   
             }
 15039   
 
 15040   
 
 15041   
             }
 15042   
 
 15043  76 
             retval.stop = input.LT(-1);
 15044   
 
 15045   
 
 15046  76 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15047  48 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15048   
 
 15049   
         }
 15050  30 
         catch (RecognitionException re) {
 15051  30 
             reportError(re);
 15052  0 
             recover(input,re);
 15053  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15054  30 
 
 15055  30 
         }
 15056   
 
 15057  30 
         finally {
 15058   
                 // do for sure before leaving
 15059  78 
         }
 15060  48 
         return retval;
 15061  30 
     }
 15062  30 
     // $ANTLR end "pathOneInPropertySet"
 15063   
 
 15064   
 
 15065  256 
     public static class triplesNode_return extends ParserRuleReturnScope {
 15066   
         Object tree;
 15067  256 
         public Object getTree() { return tree; }
 15068   
     };
 15069   
 
 15070   
 
 15071   
     // $ANTLR start "triplesNode"
 15072  30 
     // com\\googlecode\\sparkleg\\Sparql.g:472:1: triplesNode : ( '(' ( graphNode )+ ')' -> ^( COLLECTION ( graphNode )+ ) | '[' propertyListNotEmpty ']' -> ^( TRIPLES_NODE propertyListNotEmpty ) );
 15073  30 
     public final SparqlParser.triplesNode_return triplesNode() throws RecognitionException {
 15074  256 
         SparqlParser.triplesNode_return retval = new SparqlParser.triplesNode_return();
 15075  286 
         retval.start = input.LT(1);
 15076   
 
 15077   
 
 15078  256 
         Object root_0 = null;
 15079   
 
 15080  286 
         Token char_literal330=null;
 15081  286 
         Token char_literal332=null;
 15082  256 
         Token char_literal333=null;
 15083  256 
         Token char_literal335=null;
 15084  256 
         SparqlParser.graphNode_return graphNode331 =null;
 15085  30 
 
 15086  256 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty334 =null;
 15087  30 
 
 15088   
 
 15089  256 
         Object char_literal330_tree=null;
 15090  256 
         Object char_literal332_tree=null;
 15091  256 
         Object char_literal333_tree=null;
 15092  256 
         Object char_literal335_tree=null;
 15093  286 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 15094  256 
         RewriteRuleTokenStream stream_213=new RewriteRuleTokenStream(adaptor,"token 213");
 15095  256 
         RewriteRuleTokenStream stream_214=new RewriteRuleTokenStream(adaptor,"token 214");
 15096  256 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 15097  256 
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 15098  256 
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 15099  58 
         try {
 15100   
             // com\\googlecode\\sparkleg\\Sparql.g:473:5: ( '(' ( graphNode )+ ')' -> ^( COLLECTION ( graphNode )+ ) | '[' propertyListNotEmpty ']' -> ^( TRIPLES_NODE propertyListNotEmpty ) )
 15101  256 
             int alt110=2;
 15102  314 
             switch ( input.LA(1) ) {
 15103  58 
             case 209:
 15104   
                 {
 15105  112 
                 alt110=1;
 15106   
                 }
 15107  112 
                 break;
 15108   
             case 213:
 15109   
                 {
 15110  144 
                 alt110=2;
 15111   
                 }
 15112  144 
                 break;
 15113   
             default:
 15114  0 
                 NoViableAltException nvae =
 15115  58 
                     new NoViableAltException("", 110, 0, input);
 15116  58 
 
 15117  0 
                 throw nvae;
 15118   
 
 15119   
             }
 15120   
 
 15121  256 
             switch (alt110) {
 15122   
                 case 1 :
 15123  3444 
                     // com\\googlecode\\sparkleg\\Sparql.g:473:7: '(' ( graphNode )+ ')'
 15124   
                     {
 15125  112 
                     char_literal330=(Token)match(input,209,FOLLOW_209_in_triplesNode3908);
 15126  112 
                     stream_209.add(char_literal330);
 15127   
 
 15128   
 
 15129   
                     // com\\googlecode\\sparkleg\\Sparql.g:473:11: ( graphNode )+
 15130  3556 
                     int cnt109=0;
 15131  3444 
                     loop109:
 15132   
                     do {
 15133  264 
                         int alt109=2;
 15134  3708 
                         switch ( input.LA(1) ) {
 15135   
                         case BLANK_NODE_LABEL:
 15136  3444 
                         case DECIMAL:
 15137   
                         case DECIMAL_NEGATIVE:
 15138  3444 
                         case DECIMAL_POSITIVE:
 15139   
                         case DOUBLE:
 15140   
                         case DOUBLE_NEGATIVE:
 15141   
                         case DOUBLE_POSITIVE:
 15142   
                         case FALSE:
 15143   
                         case INTEGER:
 15144  3444 
                         case INTEGER_NEGATIVE:
 15145  3444 
                         case INTEGER_POSITIVE:
 15146   
                         case IRI_REF:
 15147   
                         case PNAME_LN:
 15148   
                         case PNAME_NS:
 15149   
                         case STRING_LITERAL1:
 15150   
                         case STRING_LITERAL2:
 15151   
                         case STRING_LITERAL_LONG1:
 15152   
                         case STRING_LITERAL_LONG2:
 15153   
                         case TRUE:
 15154   
                         case VAR1:
 15155   
                         case VAR2:
 15156   
                         case 209:
 15157   
                         case 213:
 15158   
                             {
 15159  152 
                             alt109=1;
 15160   
                             }
 15161   
                             break;
 15162   
 
 15163   
                         }
 15164   
 
 15165  264 
                         switch (alt109) {
 15166   
                             case 1 :
 15167   
                                 // com\\googlecode\\sparkleg\\Sparql.g:473:11: graphNode
 15168  3356 
                                 {
 15169  152 
                                 pushFollow(FOLLOW_graphNode_in_triplesNode3910);
 15170  3508 
                                 graphNode331=graphNode();
 15171   
 
 15172  152 
                                 state._fsp--;
 15173  44 
 
 15174  152 
                                 stream_graphNode.add(graphNode331.getTree());
 15175   
 
 15176  24 
                                 }
 15177  152 
                                 break;
 15178  24 
 
 15179   
                             default :
 15180  112 
                                 if ( cnt109 >= 1 ) break loop109;
 15181  0 
                                 EarlyExitException eee =
 15182   
                                     new EarlyExitException(109, input);
 15183  0 
                                 throw eee;
 15184   
                         }
 15185  152 
                         cnt109++;
 15186  152 
                     } while (true);
 15187   
 
 15188   
 
 15189  132 
                     char_literal332=(Token)match(input,210,FOLLOW_210_in_triplesNode3913);
 15190  112 
                     stream_210.add(char_literal332);
 15191  20 
 
 15192   
 
 15193   
                     // AST REWRITE
 15194   
                     // elements: graphNode
 15195   
                     // token labels:
 15196   
                     // rule labels: retval
 15197   
                     // token list labels:
 15198   
                     // rule list labels:
 15199   
                     // wildcard labels:
 15200  112 
                     retval.tree = root_0;
 15201  156 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15202   
 
 15203  112 
                     root_0 = (Object)adaptor.nil();
 15204  16 
                     // 473:26: -> ^( COLLECTION ( graphNode )+ )
 15205   
                     {
 15206   
                         // com\\googlecode\\sparkleg\\Sparql.g:473:29: ^( COLLECTION ( graphNode )+ )
 15207  4 
                         {
 15208  112 
                         Object root_1 = (Object)adaptor.nil();
 15209  116 
                         root_1 = (Object)adaptor.becomeRoot(
 15210   
                         (Object)adaptor.create(COLLECTION, "COLLECTION")
 15211   
                         , root_1);
 15212   
 
 15213  112 
                         if ( !(stream_graphNode.hasNext()) ) {
 15214  0 
                             throw new RewriteEarlyExitException();
 15215   
                         }
 15216  264 
                         while ( stream_graphNode.hasNext() ) {
 15217  152 
                             adaptor.addChild(root_1, stream_graphNode.nextTree());
 15218   
 
 15219   
                         }
 15220  112 
                         stream_graphNode.reset();
 15221   
 
 15222  112 
                         adaptor.addChild(root_0, root_1);
 15223   
                         }
 15224   
 
 15225   
                     }
 15226   
 
 15227   
 
 15228  112 
                     retval.tree = root_0;
 15229   
 
 15230   
                     }
 15231  112 
                     break;
 15232   
                 case 2 :
 15233   
                     // com\\googlecode\\sparkleg\\Sparql.g:474:7: '[' propertyListNotEmpty ']'
 15234  12 
                     {
 15235  144 
                     char_literal333=(Token)match(input,213,FOLLOW_213_in_triplesNode3930);
 15236  156 
                     stream_213.add(char_literal333);
 15237   
 
 15238   
 
 15239  144 
                     pushFollow(FOLLOW_propertyListNotEmpty_in_triplesNode3932);
 15240  144 
                     propertyListNotEmpty334=propertyListNotEmpty();
 15241   
 
 15242  144 
                     state._fsp--;
 15243   
 
 15244  144 
                     stream_propertyListNotEmpty.add(propertyListNotEmpty334.getTree());
 15245   
 
 15246  160 
                     char_literal335=(Token)match(input,214,FOLLOW_214_in_triplesNode3934);
 15247  144 
                     stream_214.add(char_literal335);
 15248  28 
 
 15249   
 
 15250   
                     // AST REWRITE
 15251  28 
                     // elements: propertyListNotEmpty
 15252   
                     // token labels:
 15253   
                     // rule labels: retval
 15254   
                     // token list labels:
 15255  3416 
                     // rule list labels:
 15256   
                     // wildcard labels:
 15257  144 
                     retval.tree = root_0;
 15258  144 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15259  3384 
 
 15260  144 
                     root_0 = (Object)adaptor.nil();
 15261   
                     // 474:36: -> ^( TRIPLES_NODE propertyListNotEmpty )
 15262  3384 
                     {
 15263  3384 
                         // com\\googlecode\\sparkleg\\Sparql.g:474:39: ^( TRIPLES_NODE propertyListNotEmpty )
 15264   
                         {
 15265  3528 
                         Object root_1 = (Object)adaptor.nil();
 15266  144 
                         root_1 = (Object)adaptor.becomeRoot(
 15267  3384 
                         (Object)adaptor.create(TRIPLES_NODE, "TRIPLES_NODE")
 15268   
                         , root_1);
 15269   
 
 15270  3528 
                         adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 15271   
 
 15272  144 
                         adaptor.addChild(root_0, root_1);
 15273   
                         }
 15274  32 
 
 15275   
                     }
 15276   
 
 15277  32 
 
 15278  176 
                     retval.tree = root_0;
 15279   
 
 15280  32 
                     }
 15281   
                     break;
 15282  32 
 
 15283   
             }
 15284  256 
             retval.stop = input.LT(-1);
 15285   
 
 15286   
 
 15287  256 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15288  3672 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15289   
 
 15290   
         }
 15291  3416 
         catch (RecognitionException re) {
 15292  3416 
             reportError(re);
 15293  0 
             recover(input,re);
 15294  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15295  28 
 
 15296  28 
         }
 15297  28 
 
 15298  28 
         finally {
 15299   
                 // do for sure before leaving
 15300  256 
         }
 15301  256 
         return retval;
 15302   
     }
 15303   
     // $ANTLR end "triplesNode"
 15304  3444 
 
 15305  3444 
 
 15306  13620 
     public static class graphNode_return extends ParserRuleReturnScope {
 15307   
         Object tree;
 15308  13620 
         public Object getTree() { return tree; }
 15309   
     };
 15310  6510 
 
 15311   
 
 15312  6510 
     // $ANTLR start "graphNode"
 15313   
     // com\\googlecode\\sparkleg\\Sparql.g:477:1: graphNode : ( varOrTerm | triplesNode );
 15314   
     public final SparqlParser.graphNode_return graphNode() throws RecognitionException {
 15315  13620 
         SparqlParser.graphNode_return retval = new SparqlParser.graphNode_return();
 15316  13620 
         retval.start = input.LT(1);
 15317   
 
 15318   
 
 15319  20130 
         Object root_0 = null;
 15320  6510 
 
 15321  13620 
         SparqlParser.varOrTerm_return varOrTerm336 =null;
 15322   
 
 15323  20130 
         SparqlParser.triplesNode_return triplesNode337 =null;
 15324   
 
 15325  6510 
 
 15326   
 
 15327  6510 
         try {
 15328   
             // com\\googlecode\\sparkleg\\Sparql.g:478:5: ( varOrTerm | triplesNode )
 15329  13620 
             int alt111=2;
 15330  13620 
             switch ( input.LA(1) ) {
 15331   
             case BLANK_NODE_LABEL:
 15332   
             case DECIMAL:
 15333  6510 
             case DECIMAL_NEGATIVE:
 15334  6510 
             case DECIMAL_POSITIVE:
 15335   
             case DOUBLE:
 15336   
             case DOUBLE_NEGATIVE:
 15337   
             case DOUBLE_POSITIVE:
 15338  4932 
             case FALSE:
 15339   
             case INTEGER:
 15340  4932 
             case INTEGER_NEGATIVE:
 15341   
             case INTEGER_POSITIVE:
 15342   
             case IRI_REF:
 15343   
             case PNAME_LN:
 15344   
             case PNAME_NS:
 15345   
             case STRING_LITERAL1:
 15346   
             case STRING_LITERAL2:
 15347   
             case STRING_LITERAL_LONG1:
 15348   
             case STRING_LITERAL_LONG2:
 15349   
             case TRUE:
 15350   
             case VAR1:
 15351   
             case VAR2:
 15352   
                 {
 15353  13352 
                 alt111=1;
 15354   
                 }
 15355  13352 
                 break;
 15356   
             case 213:
 15357   
                 {
 15358  176 
                 switch ( input.LA(2) ) {
 15359   
                 case 214:
 15360   
                     {
 15361  90 
                     alt111=1;
 15362   
                     }
 15363  1668 
                     break;
 15364   
                 case A:
 15365  1578 
                 case INVERSE:
 15366   
                 case IRI_REF:
 15367   
                 case NEGATION:
 15368   
                 case PNAME_LN:
 15369   
                 case PNAME_NS:
 15370   
                 case VAR1:
 15371   
                 case VAR2:
 15372   
                 case 209:
 15373   
                     {
 15374  6596 
                     alt111=2;
 15375   
                     }
 15376  86 
                     break;
 15377   
                 default:
 15378  4932 
                     NoViableAltException nvae =
 15379   
                         new NoViableAltException("", 111, 2, input);
 15380   
 
 15381  4932 
                     throw nvae;
 15382  4932 
 
 15383   
                 }
 15384  4932 
 
 15385   
                 }
 15386  5108 
                 break;
 15387   
             case 209:
 15388   
                 {
 15389  4996 
                 switch ( input.LA(2) ) {
 15390   
                 case 210:
 15391   
                     {
 15392  16 
                     alt111=1;
 15393  1578 
                     }
 15394  16 
                     break;
 15395   
                 case BLANK_NODE_LABEL:
 15396  1578 
                 case DECIMAL:
 15397  1578 
                 case DECIMAL_NEGATIVE:
 15398   
                 case DECIMAL_POSITIVE:
 15399  1578 
                 case DOUBLE:
 15400   
                 case DOUBLE_NEGATIVE:
 15401  1578 
                 case DOUBLE_POSITIVE:
 15402   
                 case FALSE:
 15403   
                 case INTEGER:
 15404   
                 case INTEGER_NEGATIVE:
 15405   
                 case INTEGER_POSITIVE:
 15406   
                 case IRI_REF:
 15407  6510 
                 case PNAME_LN:
 15408   
                 case PNAME_NS:
 15409   
                 case STRING_LITERAL1:
 15410  6510 
                 case STRING_LITERAL2:
 15411  6510 
                 case STRING_LITERAL_LONG1:
 15412   
                 case STRING_LITERAL_LONG2:
 15413   
                 case TRUE:
 15414   
                 case VAR1:
 15415   
                 case VAR2:
 15416   
                 case 209:
 15417   
                 case 213:
 15418   
                     {
 15419  48 
                     alt111=2;
 15420   
                     }
 15421  48 
                     break;
 15422   
                 default:
 15423  6510 
                     NoViableAltException nvae =
 15424  6510 
                         new NoViableAltException("", 111, 3, input);
 15425   
 
 15426  0 
                     throw nvae;
 15427   
 
 15428   
                 }
 15429  256 
 
 15430   
                 }
 15431  298 
                 break;
 15432   
             default:
 15433  28 
                 NoViableAltException nvae =
 15434   
                     new NoViableAltException("", 111, 0, input);
 15435   
 
 15436  28 
                 throw nvae;
 15437   
 
 15438  256 
             }
 15439  256 
 
 15440  13592 
             switch (alt111) {
 15441   
                 case 1 :
 15442  256 
                     // com\\googlecode\\sparkleg\\Sparql.g:478:7: varOrTerm
 15443   
                     {
 15444  13714 
                     root_0 = (Object)adaptor.nil();
 15445   
 
 15446  256 
 
 15447  13458 
                     pushFollow(FOLLOW_varOrTerm_in_graphNode3959);
 15448  13458 
                     varOrTerm336=varOrTerm();
 15449   
 
 15450  13458 
                     state._fsp--;
 15451   
 
 15452  13714 
                     adaptor.addChild(root_0, varOrTerm336.getTree());
 15453  256 
 
 15454   
                     }
 15455  13458 
                     break;
 15456   
                 case 2 :
 15457  146 
                     // com\\googlecode\\sparkleg\\Sparql.g:478:19: triplesNode
 15458   
                     {
 15459  280 
                     root_0 = (Object)adaptor.nil();
 15460   
 
 15461   
 
 15462  134 
                     pushFollow(FOLLOW_triplesNode_in_graphNode3963);
 15463  134 
                     triplesNode337=triplesNode();
 15464  108 
 
 15465  134 
                     state._fsp--;
 15466  108 
 
 15467  134 
                     adaptor.addChild(root_0, triplesNode337.getTree());
 15468  2 
 
 15469   
                     }
 15470   
                     break;
 15471  2 
 
 15472   
             }
 15473  13592 
             retval.stop = input.LT(-1);
 15474   
 
 15475  254 
 
 15476  13592 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15477  13592 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15478   
 
 15479  146 
         }
 15480  28 
         catch (RecognitionException re) {
 15481  28 
             reportError(re);
 15482  174 
             recover(input,re);
 15483  174 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15484   
 
 15485  146 
         }
 15486   
 
 15487  146 
         finally {
 15488   
                 // do for sure before leaving
 15489  13620 
         }
 15490  13766 
         return retval;
 15491   
     }
 15492   
     // $ANTLR end "graphNode"
 15493   
 
 15494  108 
 
 15495  25800 
     public static class varOrTerm_return extends ParserRuleReturnScope {
 15496   
         Object tree;
 15497  108 
         public Object getTree() { return tree; }
 15498  108 
     };
 15499   
 
 15500  108 
 
 15501   
     // $ANTLR start "varOrTerm"
 15502  108 
     // com\\googlecode\\sparkleg\\Sparql.g:481:1: varOrTerm : ( var | graphTerm );
 15503   
     public final SparqlParser.varOrTerm_return varOrTerm() throws RecognitionException {
 15504  25800 
         SparqlParser.varOrTerm_return retval = new SparqlParser.varOrTerm_return();
 15505  25800 
         retval.start = input.LT(1);
 15506   
 
 15507   
 
 15508  26054 
         Object root_0 = null;
 15509   
 
 15510  25800 
         SparqlParser.var_return var338 =null;
 15511  254 
 
 15512  26054 
         SparqlParser.graphTerm_return graphTerm339 =null;
 15513   
 
 15514   
 
 15515  2 
 
 15516  2 
         try {
 15517  2 
             // com\\googlecode\\sparkleg\\Sparql.g:482:5: ( var | graphTerm )
 15518  25802 
             int alt112=2;
 15519  25800 
             switch ( input.LA(1) ) {
 15520   
             case VAR1:
 15521   
             case VAR2:
 15522   
                 {
 15523  19674 
                 alt112=1;
 15524  256 
                 }
 15525  19930 
                 break;
 15526   
             case BLANK_NODE_LABEL:
 15527   
             case DECIMAL:
 15528   
             case DECIMAL_NEGATIVE:
 15529   
             case DECIMAL_POSITIVE:
 15530  8926 
             case DOUBLE:
 15531   
             case DOUBLE_NEGATIVE:
 15532  8926 
             case DOUBLE_POSITIVE:
 15533   
             case FALSE:
 15534   
             case INTEGER:
 15535   
             case INTEGER_NEGATIVE:
 15536   
             case INTEGER_POSITIVE:
 15537   
             case IRI_REF:
 15538   
             case PNAME_LN:
 15539  8926 
             case PNAME_NS:
 15540  8926 
             case STRING_LITERAL1:
 15541   
             case STRING_LITERAL2:
 15542   
             case STRING_LITERAL_LONG1:
 15543  8926 
             case STRING_LITERAL_LONG2:
 15544   
             case TRUE:
 15545  8926 
             case 209:
 15546   
             case 213:
 15547  8926 
                 {
 15548  6126 
                 alt112=2;
 15549   
                 }
 15550  6126 
                 break;
 15551   
             default:
 15552  0 
                 NoViableAltException nvae =
 15553  8926 
                     new NoViableAltException("", 112, 0, input);
 15554   
 
 15555  0 
                 throw nvae;
 15556  8926 
 
 15557   
             }
 15558  8926 
 
 15559  34726 
             switch (alt112) {
 15560  8926 
                 case 1 :
 15561   
                     // com\\googlecode\\sparkleg\\Sparql.g:482:7: var
 15562   
                     {
 15563  28600 
                     root_0 = (Object)adaptor.nil();
 15564   
 
 15565   
 
 15566  19674 
                     pushFollow(FOLLOW_var_in_varOrTerm3980);
 15567  19674 
                     var338=var();
 15568   
 
 15569  19674 
                     state._fsp--;
 15570   
 
 15571  19674 
                     adaptor.addChild(root_0, var338.getTree());
 15572   
 
 15573  8926 
                     }
 15574  19674 
                     break;
 15575   
                 case 2 :
 15576  8926 
                     // com\\googlecode\\sparkleg\\Sparql.g:483:7: graphTerm
 15577  8926 
                     {
 15578  6126 
                     root_0 = (Object)adaptor.nil();
 15579   
 
 15580   
 
 15581  6126 
                     pushFollow(FOLLOW_graphTerm_in_varOrTerm3988);
 15582  6126 
                     graphTerm339=graphTerm();
 15583   
 
 15584  6126 
                     state._fsp--;
 15585   
 
 15586  6126 
                     adaptor.addChild(root_0, graphTerm339.getTree());
 15587   
 
 15588   
                     }
 15589  8926 
                     break;
 15590  8926 
 
 15591   
             }
 15592  25800 
             retval.stop = input.LT(-1);
 15593   
 
 15594   
 
 15595  25800 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15596  25800 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15597  1578 
 
 15598   
         }
 15599  0 
         catch (RecognitionException re) {
 15600  0 
             reportError(re);
 15601  0 
             recover(input,re);
 15602  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15603   
 
 15604  1578 
         }
 15605  1578 
 
 15606  0 
         finally {
 15607   
                 // do for sure before leaving
 15608  27378 
         }
 15609  25800 
         return retval;
 15610  1578 
     }
 15611   
     // $ANTLR end "varOrTerm"
 15612  1578 
 
 15613   
 
 15614  1012 
     public static class varOrIRIref_return extends ParserRuleReturnScope {
 15615   
         Object tree;
 15616  1180 
         public Object getTree() { return tree; }
 15617   
     };
 15618  1578 
 
 15619   
 
 15620  1578 
     // $ANTLR start "varOrIRIref"
 15621   
     // com\\googlecode\\sparkleg\\Sparql.g:486:1: varOrIRIref : ( var | iriRef );
 15622   
     public final SparqlParser.varOrIRIref_return varOrIRIref() throws RecognitionException {
 15623  1012 
         SparqlParser.varOrIRIref_return retval = new SparqlParser.varOrIRIref_return();
 15624  1012 
         retval.start = input.LT(1);
 15625   
 
 15626  1578 
 
 15627  2590 
         Object root_0 = null;
 15628   
 
 15629  1012 
         SparqlParser.var_return var340 =null;
 15630   
 
 15631  1012 
         SparqlParser.iriRef_return iriRef341 =null;
 15632  1104 
 
 15633   
 
 15634  1104 
 
 15635   
         try {
 15636   
             // com\\googlecode\\sparkleg\\Sparql.g:487:5: ( var | iriRef )
 15637  1012 
             int alt113=2;
 15638  1012 
             switch ( input.LA(1) ) {
 15639   
             case VAR1:
 15640  156 
             case VAR2:
 15641   
                 {
 15642  734 
                 alt113=1;
 15643   
                 }
 15644  578 
                 break;
 15645   
             case IRI_REF:
 15646   
             case PNAME_LN:
 15647   
             case PNAME_NS:
 15648   
                 {
 15649  432 
                 alt113=2;
 15650   
                 }
 15651  432 
                 break;
 15652   
             default:
 15653  98 
                 NoViableAltException nvae =
 15654   
                     new NoViableAltException("", 113, 0, input);
 15655  96 
 
 15656  2 
                 throw nvae;
 15657   
 
 15658   
             }
 15659  4 
 
 15660  1010 
             switch (alt113) {
 15661  4 
                 case 1 :
 15662   
                     // com\\googlecode\\sparkleg\\Sparql.g:487:7: var
 15663   
                     {
 15664  578 
                     root_0 = (Object)adaptor.nil();
 15665  204 
 
 15666   
 
 15667  782 
                     pushFollow(FOLLOW_var_in_varOrIRIref4005);
 15668  578 
                     var340=var();
 15669   
 
 15670  592 
                     state._fsp--;
 15671   
 
 15672  592 
                     adaptor.addChild(root_0, var340.getTree());
 15673   
 
 15674   
                     }
 15675  578 
                     break;
 15676   
                 case 2 :
 15677   
                     // com\\googlecode\\sparkleg\\Sparql.g:487:13: iriRef
 15678   
                     {
 15679  432 
                     root_0 = (Object)adaptor.nil();
 15680   
 
 15681  1578 
 
 15682  432 
                     pushFollow(FOLLOW_iriRef_in_varOrIRIref4009);
 15683  432 
                     iriRef341=iriRef();
 15684   
 
 15685  1536 
                     state._fsp--;
 15686   
 
 15687  432 
                     adaptor.addChild(root_0, iriRef341.getTree());
 15688  1104 
 
 15689  1104 
                     }
 15690   
                     break;
 15691  1104 
 
 15692   
             }
 15693  2114 
             retval.stop = input.LT(-1);
 15694   
 
 15695   
 
 15696  2114 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15697  1010 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15698   
 
 15699   
         }
 15700  158 
         catch (RecognitionException re) {
 15701  2 
             reportError(re);
 15702  2 
             recover(input,re);
 15703  158 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15704  156 
 
 15705   
         }
 15706  156 
 
 15707  0 
         finally {
 15708  156 
                 // do for sure before leaving
 15709  1012 
         }
 15710  1012 
         return retval;
 15711  156 
     }
 15712   
     // $ANTLR end "varOrIRIref"
 15713   
 
 15714   
 
 15715  35602 
     public static class var_return extends ParserRuleReturnScope {
 15716   
         Object tree;
 15717  35602 
         public Object getTree() { return tree; }
 15718  96 
     };
 15719  96 
 
 15720   
 
 15721  96 
     // $ANTLR start "var"
 15722   
     // com\\googlecode\\sparkleg\\Sparql.g:490:1: var : ( VAR1 | VAR2 );
 15723  96 
     public final SparqlParser.var_return var() throws RecognitionException {
 15724  35602 
         SparqlParser.var_return retval = new SparqlParser.var_return();
 15725  35602 
         retval.start = input.LT(1);
 15726  96 
 
 15727   
 
 15728  35602 
         Object root_0 = null;
 15729   
 
 15730  35606 
         Token set342=null;
 15731   
 
 15732  35602 
         Object set342_tree=null;
 15733  4 
 
 15734  4 
         try {
 15735   
             // com\\googlecode\\sparkleg\\Sparql.g:491:5: ( VAR1 | VAR2 )
 15736  4 
             // com\\googlecode\\sparkleg\\Sparql.g:
 15737   
             {
 15738  35606 
             root_0 = (Object)adaptor.nil();
 15739   
 
 15740   
 
 15741  35606 
             set342=(Token)input.LT(1);
 15742   
 
 15743  35602 
             if ( (input.LA(1) >= VAR1 && input.LA(1) <= VAR2) ) {
 15744  35602 
                 input.consume();
 15745  35806 
                 adaptor.addChild(root_0,
 15746   
                 (Object)adaptor.create(set342)
 15747   
                 );
 15748  35806 
                 state.errorRecovery=false;
 15749  204 
             }
 15750   
             else {
 15751  204 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 15752  0 
                 throw mse;
 15753  204 
             }
 15754   
 
 15755   
 
 15756  204 
             }
 15757   
 
 15758  35602 
             retval.stop = input.LT(-1);
 15759   
 
 15760  14 
 
 15761  35602 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15762  35602 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15763  14 
 
 15764  14 
         }
 15765  0 
         catch (RecognitionException re) {
 15766  14 
             reportError(re);
 15767  0 
             recover(input,re);
 15768  14 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15769   
 
 15770   
         }
 15771   
 
 15772  0 
         finally {
 15773   
                 // do for sure before leaving
 15774  37180 
         }
 15775  35602 
         return retval;
 15776   
     }
 15777  1578 
     // $ANTLR end "var"
 15778  1578 
 
 15779   
 
 15780  6126 
     public static class graphTerm_return extends ParserRuleReturnScope {
 15781   
         Object tree;
 15782  6126 
         public Object getTree() { return tree; }
 15783   
     };
 15784   
 
 15785   
 
 15786   
     // $ANTLR start "graphTerm"
 15787   
     // com\\googlecode\\sparkleg\\Sparql.g:494:1: graphTerm : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil );
 15788   
     public final SparqlParser.graphTerm_return graphTerm() throws RecognitionException {
 15789  6126 
         SparqlParser.graphTerm_return retval = new SparqlParser.graphTerm_return();
 15790  7704 
         retval.start = input.LT(1);
 15791  1578 
 
 15792   
 
 15793  6126 
         Object root_0 = null;
 15794   
 
 15795  6126 
         SparqlParser.iriRef_return iriRef343 =null;
 15796  30 
 
 15797  6126 
         SparqlParser.rdfLiteral_return rdfLiteral344 =null;
 15798  30 
 
 15799  6126 
         SparqlParser.numericLiteral_return numericLiteral345 =null;
 15800   
 
 15801  6126 
         SparqlParser.booleanLiteral_return booleanLiteral346 =null;
 15802   
 
 15803  6126 
         SparqlParser.blankNode_return blankNode347 =null;
 15804   
 
 15805  6156 
         SparqlParser.nil_return nil348 =null;
 15806  30 
 
 15807   
 
 15808   
 
 15809  30 
         try {
 15810   
             // com\\googlecode\\sparkleg\\Sparql.g:495:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil )
 15811  6156 
             int alt114=6;
 15812  6156 
             switch ( input.LA(1) ) {
 15813   
             case IRI_REF:
 15814  30 
             case PNAME_LN:
 15815  30 
             case PNAME_NS:
 15816   
                 {
 15817  4284 
                 alt114=1;
 15818   
                 }
 15819  4284 
                 break;
 15820   
             case STRING_LITERAL1:
 15821  30 
             case STRING_LITERAL2:
 15822   
             case STRING_LITERAL_LONG1:
 15823   
             case STRING_LITERAL_LONG2:
 15824  30 
                 {
 15825  654 
                 alt114=2;
 15826   
                 }
 15827  624 
                 break;
 15828  30 
             case DECIMAL:
 15829   
             case DECIMAL_NEGATIVE:
 15830   
             case DECIMAL_POSITIVE:
 15831  30 
             case DOUBLE:
 15832  30 
             case DOUBLE_NEGATIVE:
 15833   
             case DOUBLE_POSITIVE:
 15834   
             case INTEGER:
 15835  30 
             case INTEGER_NEGATIVE:
 15836   
             case INTEGER_POSITIVE:
 15837   
                 {
 15838  378 
                 alt114=3;
 15839   
                 }
 15840  408 
                 break;
 15841   
             case FALSE:
 15842   
             case TRUE:
 15843  30 
                 {
 15844  46 
                 alt114=4;
 15845   
                 }
 15846  16 
                 break;
 15847   
             case BLANK_NODE_LABEL:
 15848   
             case 213:
 15849   
                 {
 15850  780 
                 alt114=5;
 15851   
                 }
 15852  780 
                 break;
 15853   
             case 209:
 15854   
                 {
 15855  44 
                 alt114=6;
 15856  30 
                 }
 15857  74 
                 break;
 15858   
             default:
 15859  0 
                 NoViableAltException nvae =
 15860   
                     new NoViableAltException("", 114, 0, input);
 15861   
 
 15862  0 
                 throw nvae;
 15863   
 
 15864  1650 
             }
 15865   
 
 15866  6126 
             switch (alt114) {
 15867   
                 case 1 :
 15868   
                     // com\\googlecode\\sparkleg\\Sparql.g:495:7: iriRef
 15869   
                     {
 15870  4284 
                     root_0 = (Object)adaptor.nil();
 15871  1650 
 
 15872  1650 
 
 15873  4284 
                     pushFollow(FOLLOW_iriRef_in_graphTerm4047);
 15874  4284 
                     iriRef343=iriRef();
 15875  1650 
 
 15876  4284 
                     state._fsp--;
 15877  1650 
 
 15878  4284 
                     adaptor.addChild(root_0, iriRef343.getTree());
 15879   
 
 15880   
                     }
 15881  4284 
                     break;
 15882   
                 case 2 :
 15883   
                     // com\\googlecode\\sparkleg\\Sparql.g:496:7: rdfLiteral
 15884   
                     {
 15885  2274 
                     root_0 = (Object)adaptor.nil();
 15886   
 
 15887   
 
 15888  2274 
                     pushFollow(FOLLOW_rdfLiteral_in_graphTerm4055);
 15889  2274 
                     rdfLiteral344=rdfLiteral();
 15890   
 
 15891  2274 
                     state._fsp--;
 15892   
 
 15893  2274 
                     adaptor.addChild(root_0, rdfLiteral344.getTree());
 15894   
 
 15895   
                     }
 15896  624 
                     break;
 15897  1650 
                 case 3 :
 15898   
                     // com\\googlecode\\sparkleg\\Sparql.g:497:7: numericLiteral
 15899   
                     {
 15900  2028 
                     root_0 = (Object)adaptor.nil();
 15901  1650 
 
 15902   
 
 15903  378 
                     pushFollow(FOLLOW_numericLiteral_in_graphTerm4063);
 15904  378 
                     numericLiteral345=numericLiteral();
 15905   
 
 15906  378 
                     state._fsp--;
 15907   
 
 15908  378 
                     adaptor.addChild(root_0, numericLiteral345.getTree());
 15909   
 
 15910   
                     }
 15911  378 
                     break;
 15912   
                 case 4 :
 15913  1650 
                     // com\\googlecode\\sparkleg\\Sparql.g:498:7: booleanLiteral
 15914  1650 
                     {
 15915  16 
                     root_0 = (Object)adaptor.nil();
 15916   
 
 15917   
 
 15918  16 
                     pushFollow(FOLLOW_booleanLiteral_in_graphTerm4071);
 15919  16 
                     booleanLiteral346=booleanLiteral();
 15920   
 
 15921  16 
                     state._fsp--;
 15922   
 
 15923  16 
                     adaptor.addChild(root_0, booleanLiteral346.getTree());
 15924   
 
 15925   
                     }
 15926  16 
                     break;
 15927   
                 case 5 :
 15928  1650 
                     // com\\googlecode\\sparkleg\\Sparql.g:499:7: blankNode
 15929  1650 
                     {
 15930  780 
                     root_0 = (Object)adaptor.nil();
 15931   
 
 15932  1650 
 
 15933  780 
                     pushFollow(FOLLOW_blankNode_in_graphTerm4079);
 15934  2430 
                     blankNode347=blankNode();
 15935  1650 
 
 15936  780 
                     state._fsp--;
 15937  1650 
 
 15938  780 
                     adaptor.addChild(root_0, blankNode347.getTree());
 15939   
 
 15940  1650 
                     }
 15941  2430 
                     break;
 15942  1650 
                 case 6 :
 15943   
                     // com\\googlecode\\sparkleg\\Sparql.g:500:7: nil
 15944   
                     {
 15945  44 
                     root_0 = (Object)adaptor.nil();
 15946   
 
 15947   
 
 15948  44 
                     pushFollow(FOLLOW_nil_in_graphTerm4087);
 15949  44 
                     nil348=nil();
 15950  1650 
 
 15951  1694 
                     state._fsp--;
 15952   
 
 15953  1694 
                     adaptor.addChild(root_0, nil348.getTree());
 15954   
 
 15955  1650 
                     }
 15956   
                     break;
 15957   
 
 15958   
             }
 15959  6126 
             retval.stop = input.LT(-1);
 15960   
 
 15961   
 
 15962  6126 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15963  6126 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15964  1650 
 
 15965  1650 
         }
 15966  1650 
         catch (RecognitionException re) {
 15967  0 
             reportError(re);
 15968  1650 
             recover(input,re);
 15969  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15970   
 
 15971  1650 
         }
 15972   
 
 15973  0 
         finally {
 15974   
                 // do for sure before leaving
 15975  6126 
         }
 15976  7776 
         return retval;
 15977   
     }
 15978   
     // $ANTLR end "graphTerm"
 15979   
 
 15980   
 
 15981  300 
     public static class nil_return extends ParserRuleReturnScope {
 15982   
         Object tree;
 15983  300 
         public Object getTree() { return tree; }
 15984  1698 
     };
 15985  1698 
 
 15986   
 
 15987   
     // $ANTLR start "nil"
 15988  48 
     // com\\googlecode\\sparkleg\\Sparql.g:503:1: nil : '(' ')' -> NIL ;
 15989   
     public final SparqlParser.nil_return nil() throws RecognitionException {
 15990  300 
         SparqlParser.nil_return retval = new SparqlParser.nil_return();
 15991  300 
         retval.start = input.LT(1);
 15992   
 
 15993   
 
 15994  1998 
         Object root_0 = null;
 15995   
 
 15996  300 
         Token char_literal349=null;
 15997  300 
         Token char_literal350=null;
 15998  48 
 
 15999  348 
         Object char_literal349_tree=null;
 16000  300 
         Object char_literal350_tree=null;
 16001  300 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 16002  348 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 16003  48 
 
 16004   
         try {
 16005  48 
             // com\\googlecode\\sparkleg\\Sparql.g:504:5: ( '(' ')' -> NIL )
 16006   
             // com\\googlecode\\sparkleg\\Sparql.g:504:7: '(' ')'
 16007  48 
             {
 16008  300 
             char_literal349=(Token)match(input,209,FOLLOW_209_in_nil4108);
 16009  300 
             stream_209.add(char_literal349);
 16010   
 
 16011   
 
 16012  300 
             char_literal350=(Token)match(input,210,FOLLOW_210_in_nil4110);
 16013  300 
             stream_210.add(char_literal350);
 16014   
 
 16015   
 
 16016  48 
             // AST REWRITE
 16017  48 
             // elements:
 16018  48 
             // token labels:
 16019   
             // rule labels: retval
 16020  48 
             // token list labels:
 16021   
             // rule list labels:
 16022   
             // wildcard labels:
 16023  300 
             retval.tree = root_0;
 16024  300 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16025  48 
 
 16026  348 
             root_0 = (Object)adaptor.nil();
 16027   
             // 504:15: -> NIL
 16028   
             {
 16029  300 
                 adaptor.addChild(root_0,
 16030  48 
                 (Object)adaptor.create(NIL, "NIL")
 16031   
                 );
 16032  48 
 
 16033   
             }
 16034  48 
 
 16035   
 
 16036  300 
             retval.tree = root_0;
 16037   
 
 16038   
             }
 16039   
 
 16040  348 
             retval.stop = input.LT(-1);
 16041   
 
 16042   
 
 16043  348 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16044  300 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16045   
 
 16046  1650 
         }
 16047  0 
         catch (RecognitionException re) {
 16048  48 
             reportError(re);
 16049  0 
             recover(input,re);
 16050  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16051   
 
 16052   
         }
 16053  1650 
 
 16054  0 
         finally {
 16055   
                 // do for sure before leaving
 16056  1950 
         }
 16057  1950 
         return retval;
 16058   
     }
 16059   
     // $ANTLR end "nil"
 16060   
 
 16061   
 
 16062  6564 
     public static class expression_return extends ParserRuleReturnScope {
 16063   
         Object tree;
 16064  6564 
         public Object getTree() { return tree; }
 16065   
     };
 16066   
 
 16067   
 
 16068   
     // $ANTLR start "expression"
 16069  1650 
     // com\\googlecode\\sparkleg\\Sparql.g:507:1: expression : conditionalOrExpression ;
 16070  1650 
     public final SparqlParser.expression_return expression() throws RecognitionException {
 16071  6564 
         SparqlParser.expression_return retval = new SparqlParser.expression_return();
 16072  6564 
         retval.start = input.LT(1);
 16073   
 
 16074   
 
 16075  1698 
         Object root_0 = null;
 16076   
 
 16077  1698 
         SparqlParser.conditionalOrExpression_return conditionalOrExpression351 =null;
 16078   
 
 16079   
 
 16080   
 
 16081   
         try {
 16082   
             // com\\googlecode\\sparkleg\\Sparql.g:508:5: ( conditionalOrExpression )
 16083   
             // com\\googlecode\\sparkleg\\Sparql.g:508:7: conditionalOrExpression
 16084  1698 
             {
 16085  8262 
             root_0 = (Object)adaptor.nil();
 16086   
 
 16087   
 
 16088  8262 
             pushFollow(FOLLOW_conditionalOrExpression_in_expression4131);
 16089  6564 
             conditionalOrExpression351=conditionalOrExpression();
 16090  1698 
 
 16091  8262 
             state._fsp--;
 16092   
 
 16093  8262 
             adaptor.addChild(root_0, conditionalOrExpression351.getTree());
 16094   
 
 16095   
             }
 16096  1698 
 
 16097  8262 
             retval.stop = input.LT(-1);
 16098  1698 
 
 16099   
 
 16100  6564 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16101  6564 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16102   
 
 16103   
         }
 16104  0 
         catch (RecognitionException re) {
 16105  0 
             reportError(re);
 16106  1698 
             recover(input,re);
 16107  1698 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16108   
 
 16109  1698 
         }
 16110   
 
 16111  1698 
         finally {
 16112   
                 // do for sure before leaving
 16113  6564 
         }
 16114  6564 
         return retval;
 16115   
     }
 16116   
     // $ANTLR end "expression"
 16117   
 
 16118   
 
 16119  6564 
     public static class conditionalOrExpression_return extends ParserRuleReturnScope {
 16120  1698 
         Object tree;
 16121  1698 
         public Object getTree() { return tree; }
 16122  1698 
     };
 16123   
 
 16124  1698 
 
 16125   
     // $ANTLR start "conditionalOrExpression"
 16126   
     // com\\googlecode\\sparkleg\\Sparql.g:511:1: conditionalOrExpression : (c1= conditionalAndExpression -> $c1) ( '||' c2= conditionalAndExpression -> ^( '||' $conditionalOrExpression $c2) )* ;
 16127  1698 
     public final SparqlParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
 16128  6564 
         SparqlParser.conditionalOrExpression_return retval = new SparqlParser.conditionalOrExpression_return();
 16129  6564 
         retval.start = input.LT(1);
 16130   
 
 16131   
 
 16132  8262 
         Object root_0 = null;
 16133   
 
 16134  6564 
         Token string_literal352=null;
 16135  6564 
         SparqlParser.conditionalAndExpression_return c1 =null;
 16136   
 
 16137  6564 
         SparqlParser.conditionalAndExpression_return c2 =null;
 16138   
 
 16139   
 
 16140  8310 
         Object string_literal352_tree=null;
 16141  8310 
         RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
 16142  6564 
         RewriteRuleSubtreeStream stream_conditionalAndExpression=new RewriteRuleSubtreeStream(adaptor,"rule conditionalAndExpression");
 16143   
         try {
 16144  48 
             // com\\googlecode\\sparkleg\\Sparql.g:512:5: ( (c1= conditionalAndExpression -> $c1) ( '||' c2= conditionalAndExpression -> ^( '||' $conditionalOrExpression $c2) )* )
 16145   
             // com\\googlecode\\sparkleg\\Sparql.g:512:7: (c1= conditionalAndExpression -> $c1) ( '||' c2= conditionalAndExpression -> ^( '||' $conditionalOrExpression $c2) )*
 16146   
             {
 16147   
             // com\\googlecode\\sparkleg\\Sparql.g:512:7: (c1= conditionalAndExpression -> $c1)
 16148   
             // com\\googlecode\\sparkleg\\Sparql.g:512:8: c1= conditionalAndExpression
 16149   
             {
 16150  8310 
             pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression4151);
 16151  6564 
             c1=conditionalAndExpression();
 16152   
 
 16153  6564 
             state._fsp--;
 16154  48 
 
 16155  6612 
             stream_conditionalAndExpression.add(c1.getTree());
 16156   
 
 16157   
             // AST REWRITE
 16158  48 
             // elements: c1
 16159  48 
             // token labels:
 16160   
             // rule labels: retval, c1
 16161  48 
             // token list labels:
 16162   
             // rule list labels:
 16163  48 
             // wildcard labels:
 16164  6564 
             retval.tree = root_0;
 16165  6564 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16166  6564 
             RewriteRuleSubtreeStream stream_c1=new RewriteRuleSubtreeStream(adaptor,"rule c1",c1!=null?c1.tree:null);
 16167   
 
 16168  6564 
             root_0 = (Object)adaptor.nil();
 16169   
             // 512:36: -> $c1
 16170   
             {
 16171  6564 
                 adaptor.addChild(root_0, stream_c1.nextTree());
 16172  48 
 
 16173  48 
             }
 16174  48 
 
 16175   
 
 16176  6612 
             retval.tree = root_0;
 16177   
 
 16178   
             }
 16179   
 
 16180   
 
 16181  48 
             // com\\googlecode\\sparkleg\\Sparql.g:512:44: ( '||' c2= conditionalAndExpression -> ^( '||' $conditionalOrExpression $c2) )*
 16182  48 
             loop115:
 16183   
             do {
 16184  6756 
                 int alt115=2;
 16185  6756 
                 switch ( input.LA(1) ) {
 16186  48 
                 case OR:
 16187   
                     {
 16188  240 
                     alt115=1;
 16189   
                     }
 16190  48 
                     break;
 16191   
 
 16192   
                 }
 16193   
 
 16194  6756 
                 switch (alt115) {
 16195   
                     case 1 :
 16196  48 
                         // com\\googlecode\\sparkleg\\Sparql.g:512:45: '||' c2= conditionalAndExpression
 16197   
                         {
 16198  192 
                         string_literal352=(Token)match(input,OR,FOLLOW_OR_in_conditionalOrExpression4160);
 16199  240 
                         stream_OR.add(string_literal352);
 16200   
 
 16201   
 
 16202  1890 
                         pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression4164);
 16203  192 
                         c2=conditionalAndExpression();
 16204  48 
 
 16205  192 
                         state._fsp--;
 16206   
 
 16207  192 
                         stream_conditionalAndExpression.add(c2.getTree());
 16208   
 
 16209  1698 
                         // AST REWRITE
 16210   
                         // elements: c2, conditionalOrExpression, OR
 16211   
                         // token labels:
 16212  1698 
                         // rule labels: retval, c2
 16213  1698 
                         // token list labels:
 16214   
                         // rule list labels:
 16215   
                         // wildcard labels:
 16216  192 
                         retval.tree = root_0;
 16217  192 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16218  192 
                         RewriteRuleSubtreeStream stream_c2=new RewriteRuleSubtreeStream(adaptor,"rule c2",c2!=null?c2.tree:null);
 16219   
 
 16220  192 
                         root_0 = (Object)adaptor.nil();
 16221   
                         // 512:78: -> ^( '||' $conditionalOrExpression $c2)
 16222   
                         {
 16223   
                             // com\\googlecode\\sparkleg\\Sparql.g:512:81: ^( '||' $conditionalOrExpression $c2)
 16224   
                             {
 16225  1890 
                             Object root_1 = (Object)adaptor.nil();
 16226  1890 
                             root_1 = (Object)adaptor.becomeRoot(
 16227   
                             stream_OR.nextNode()
 16228   
                             , root_1);
 16229   
 
 16230  192 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 16231  1746 
 
 16232  192 
                             adaptor.addChild(root_1, stream_c2.nextTree());
 16233  1746 
 
 16234  192 
                             adaptor.addChild(root_0, root_1);
 16235   
                             }
 16236   
 
 16237   
                         }
 16238   
 
 16239   
 
 16240  1938 
                         retval.tree = root_0;
 16241  1746 
 
 16242   
                         }
 16243  192 
                         break;
 16244  1746 
 
 16245   
                     default :
 16246  8310 
                         break loop115;
 16247   
                 }
 16248  192 
             } while (true);
 16249   
 
 16250   
 
 16251   
             }
 16252   
 
 16253  6564 
             retval.stop = input.LT(-1);
 16254  1746 
 
 16255   
 
 16256  6564 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16257  8310 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16258  1746 
 
 16259   
         }
 16260  1746 
         catch (RecognitionException re) {
 16261  0 
             reportError(re);
 16262  1746 
             recover(input,re);
 16263  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16264   
 
 16265   
         }
 16266  1746 
 
 16267  0 
         finally {
 16268   
                 // do for sure before leaving
 16269  8310 
         }
 16270  8310 
         return retval;
 16271   
     }
 16272   
     // $ANTLR end "conditionalOrExpression"
 16273   
 
 16274   
 
 16275  6756 
     public static class conditionalAndExpression_return extends ParserRuleReturnScope {
 16276   
         Object tree;
 16277  6756 
         public Object getTree() { return tree; }
 16278   
     };
 16279   
 
 16280   
 
 16281   
     // $ANTLR start "conditionalAndExpression"
 16282  1746 
     // com\\googlecode\\sparkleg\\Sparql.g:515:1: conditionalAndExpression : (v1= valueLogical -> $v1) ( '&&' v2= valueLogical -> ^( '&&' $conditionalAndExpression $v2) )* ;
 16283  1746 
     public final SparqlParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
 16284  6756 
         SparqlParser.conditionalAndExpression_return retval = new SparqlParser.conditionalAndExpression_return();
 16285  6756 
         retval.start = input.LT(1);
 16286   
 
 16287   
 
 16288  6756 
         Object root_0 = null;
 16289   
 
 16290  6756 
         Token string_literal353=null;
 16291  6756 
         SparqlParser.valueLogical_return v1 =null;
 16292   
 
 16293  6756 
         SparqlParser.valueLogical_return v2 =null;
 16294   
 
 16295   
 
 16296  6756 
         Object string_literal353_tree=null;
 16297  8502 
         RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
 16298  8502 
         RewriteRuleSubtreeStream stream_valueLogical=new RewriteRuleSubtreeStream(adaptor,"rule valueLogical");
 16299   
         try {
 16300   
             // com\\googlecode\\sparkleg\\Sparql.g:516:5: ( (v1= valueLogical -> $v1) ( '&&' v2= valueLogical -> ^( '&&' $conditionalAndExpression $v2) )* )
 16301  1746 
             // com\\googlecode\\sparkleg\\Sparql.g:516:7: (v1= valueLogical -> $v1) ( '&&' v2= valueLogical -> ^( '&&' $conditionalAndExpression $v2) )*
 16302   
             {
 16303  1746 
             // com\\googlecode\\sparkleg\\Sparql.g:516:7: (v1= valueLogical -> $v1)
 16304  1746 
             // com\\googlecode\\sparkleg\\Sparql.g:516:8: v1= valueLogical
 16305  1746 
             {
 16306  8502 
             pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression4198);
 16307  8502 
             v1=valueLogical();
 16308  1746 
 
 16309  8502 
             state._fsp--;
 16310  1746 
 
 16311  8502 
             stream_valueLogical.add(v1.getTree());
 16312  1746 
 
 16313   
             // AST REWRITE
 16314  1746 
             // elements: v1
 16315   
             // token labels:
 16316  1746 
             // rule labels: v1, retval
 16317   
             // token list labels:
 16318  1746 
             // rule list labels:
 16319   
             // wildcard labels:
 16320  8502 
             retval.tree = root_0;
 16321  6756 
             RewriteRuleSubtreeStream stream_v1=new RewriteRuleSubtreeStream(adaptor,"rule v1",v1!=null?v1.tree:null);
 16322  8502 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16323   
 
 16324  8502 
             root_0 = (Object)adaptor.nil();
 16325   
             // 516:24: -> $v1
 16326  1746 
             {
 16327  6756 
                 adaptor.addChild(root_0, stream_v1.nextTree());
 16328  1746 
 
 16329   
             }
 16330   
 
 16331  1746 
 
 16332  8502 
             retval.tree = root_0;
 16333  1746 
 
 16334  1746 
             }
 16335  1746 
 
 16336  1746 
 
 16337  1746 
             // com\\googlecode\\sparkleg\\Sparql.g:516:32: ( '&&' v2= valueLogical -> ^( '&&' $conditionalAndExpression $v2) )*
 16338  1746 
             loop116:
 16339  1746 
             do {
 16340  8694 
                 int alt116=2;
 16341  8694 
                 switch ( input.LA(1) ) {
 16342  1746 
                 case AND:
 16343  1746 
                     {
 16344  1938 
                     alt116=1;
 16345  1746 
                     }
 16346  1746 
                     break;
 16347  1746 
 
 16348  1746 
                 }
 16349  1746 
 
 16350  6948 
                 switch (alt116) {
 16351   
                     case 1 :
 16352   
                         // com\\googlecode\\sparkleg\\Sparql.g:516:33: '&&' v2= valueLogical
 16353   
                         {
 16354  192 
                         string_literal353=(Token)match(input,AND,FOLLOW_AND_in_conditionalAndExpression4207);
 16355  192 
                         stream_AND.add(string_literal353);
 16356   
 
 16357  1746 
 
 16358  1938 
                         pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression4211);
 16359  192 
                         v2=valueLogical();
 16360  1746 
 
 16361  192 
                         state._fsp--;
 16362  1746 
 
 16363  192 
                         stream_valueLogical.add(v2.getTree());
 16364   
 
 16365   
                         // AST REWRITE
 16366   
                         // elements: v2, conditionalAndExpression, AND
 16367   
                         // token labels:
 16368   
                         // rule labels: retval, v2
 16369   
                         // token list labels:
 16370   
                         // rule list labels:
 16371  1746 
                         // wildcard labels:
 16372  1938 
                         retval.tree = root_0;
 16373  1938 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16374  192 
                         RewriteRuleSubtreeStream stream_v2=new RewriteRuleSubtreeStream(adaptor,"rule v2",v2!=null?v2.tree:null);
 16375  1746 
 
 16376  192 
                         root_0 = (Object)adaptor.nil();
 16377   
                         // 516:54: -> ^( '&&' $conditionalAndExpression $v2)
 16378  1746 
                         {
 16379   
                             // com\\googlecode\\sparkleg\\Sparql.g:516:57: ^( '&&' $conditionalAndExpression $v2)
 16380   
                             {
 16381  192 
                             Object root_1 = (Object)adaptor.nil();
 16382  192 
                             root_1 = (Object)adaptor.becomeRoot(
 16383  1746 
                             stream_AND.nextNode()
 16384   
                             , root_1);
 16385   
 
 16386  192 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 16387   
 
 16388  192 
                             adaptor.addChild(root_1, stream_v2.nextTree());
 16389  1746 
 
 16390  1938 
                             adaptor.addChild(root_0, root_1);
 16391   
                             }
 16392   
 
 16393  274 
                         }
 16394   
 
 16395  274 
 
 16396  192 
                         retval.tree = root_0;
 16397   
 
 16398  56 
                         }
 16399  192 
                         break;
 16400  56 
 
 16401   
                     default :
 16402  6756 
                         break loop116;
 16403  36 
                 }
 16404  192 
             } while (true);
 16405  36 
 
 16406   
 
 16407   
             }
 16408  36 
 
 16409  6756 
             retval.stop = input.LT(-1);
 16410  36 
 
 16411   
 
 16412  6756 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16413  6760 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16414   
 
 16415  4 
         }
 16416  0 
         catch (RecognitionException re) {
 16417  0 
             reportError(re);
 16418  6 
             recover(input,re);
 16419  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16420  6 
 
 16421   
         }
 16422   
 
 16423  4 
         finally {
 16424   
                 // do for sure before leaving
 16425  6760 
         }
 16426  6756 
         return retval;
 16427   
     }
 16428  4 
     // $ANTLR end "conditionalAndExpression"
 16429   
 
 16430   
 
 16431  6948 
     public static class valueLogical_return extends ParserRuleReturnScope {
 16432   
         Object tree;
 16433  1746 
         public Object getTree() { return tree; }
 16434   
     };
 16435   
 
 16436   
 
 16437   
     // $ANTLR start "valueLogical"
 16438   
     // com\\googlecode\\sparkleg\\Sparql.g:519:1: valueLogical : relationalExpression ;
 16439   
     public final SparqlParser.valueLogical_return valueLogical() throws RecognitionException {
 16440  7222 
         SparqlParser.valueLogical_return retval = new SparqlParser.valueLogical_return();
 16441  7222 
         retval.start = input.LT(1);
 16442   
 
 16443   
 
 16444  7222 
         Object root_0 = null;
 16445  274 
 
 16446  6948 
         SparqlParser.relationalExpression_return relationalExpression354 =null;
 16447  274 
 
 16448   
 
 16449  274 
 
 16450   
         try {
 16451   
             // com\\googlecode\\sparkleg\\Sparql.g:520:5: ( relationalExpression )
 16452   
             // com\\googlecode\\sparkleg\\Sparql.g:520:7: relationalExpression
 16453   
             {
 16454  6948 
             root_0 = (Object)adaptor.nil();
 16455   
 
 16456   
 
 16457  6948 
             pushFollow(FOLLOW_relationalExpression_in_valueLogical4242);
 16458  7222 
             relationalExpression354=relationalExpression();
 16459  274 
 
 16460  7222 
             state._fsp--;
 16461   
 
 16462  7222 
             adaptor.addChild(root_0, relationalExpression354.getTree());
 16463   
 
 16464   
             }
 16465   
 
 16466  6948 
             retval.stop = input.LT(-1);
 16467  274 
 
 16468  274 
 
 16469  6948 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16470  6948 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16471   
 
 16472  274 
         }
 16473  0 
         catch (RecognitionException re) {
 16474  274 
             reportError(re);
 16475  0 
             recover(input,re);
 16476  274 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16477   
 
 16478   
         }
 16479   
 
 16480  0 
         finally {
 16481   
                 // do for sure before leaving
 16482  7222 
         }
 16483  6948 
         return retval;
 16484   
     }
 16485   
     // $ANTLR end "valueLogical"
 16486   
 
 16487   
 
 16488  274 
     public static class relationalExpression_return extends ParserRuleReturnScope {
 16489   
         Object tree;
 16490  6948 
         public Object getTree() { return tree; }
 16491   
     };
 16492   
 
 16493   
 
 16494   
     // $ANTLR start "relationalExpression"
 16495  56 
     // com\\googlecode\\sparkleg\\Sparql.g:523:1: relationalExpression : (n1= numericExpression -> $n1) ( ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) ) | ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) ) | ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) ) | ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) ) | ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) ) | ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? ;
 16496  56 
     public final SparqlParser.relationalExpression_return relationalExpression() throws RecognitionException {
 16497  6948 
         SparqlParser.relationalExpression_return retval = new SparqlParser.relationalExpression_return();
 16498  6948 
         retval.start = input.LT(1);
 16499  56 
 
 16500  56 
 
 16501  6948 
         Object root_0 = null;
 16502  56 
 
 16503  6948 
         Token char_literal355=null;
 16504  7004 
         Token string_literal356=null;
 16505  6948 
         Token char_literal357=null;
 16506  6948 
         Token char_literal358=null;
 16507  6948 
         Token string_literal359=null;
 16508  6948 
         Token string_literal360=null;
 16509  6948 
         Token IN361=null;
 16510  6948 
         Token NOT362=null;
 16511  6948 
         Token IN363=null;
 16512  6948 
         SparqlParser.numericExpression_return n1 =null;
 16513  56 
 
 16514  7004 
         SparqlParser.numericExpression_return n2 =null;
 16515  56 
 
 16516  6948 
         SparqlParser.numericExpression_return n3 =null;
 16517  56 
 
 16518  6948 
         SparqlParser.numericExpression_return n4 =null;
 16519   
 
 16520  6948 
         SparqlParser.numericExpression_return n5 =null;
 16521   
 
 16522  7004 
         SparqlParser.numericExpression_return n6 =null;
 16523  56 
 
 16524  6948 
         SparqlParser.numericExpression_return n7 =null;
 16525   
 
 16526  6948 
         SparqlParser.expressionList_return l2 =null;
 16527  56 
 
 16528  6948 
         SparqlParser.expressionList_return l3 =null;
 16529  56 
 
 16530   
 
 16531  7004 
         Object char_literal355_tree=null;
 16532  6948 
         Object string_literal356_tree=null;
 16533  6948 
         Object char_literal357_tree=null;
 16534  6948 
         Object char_literal358_tree=null;
 16535  6948 
         Object string_literal359_tree=null;
 16536  6948 
         Object string_literal360_tree=null;
 16537  7004 
         Object IN361_tree=null;
 16538  6948 
         Object NOT362_tree=null;
 16539  6948 
         Object IN363_tree=null;
 16540  6948 
         RewriteRuleTokenStream stream_GREATER=new RewriteRuleTokenStream(adaptor,"token GREATER");
 16541  6948 
         RewriteRuleTokenStream stream_LESS_EQUAL=new RewriteRuleTokenStream(adaptor,"token LESS_EQUAL");
 16542  6948 
         RewriteRuleTokenStream stream_IN=new RewriteRuleTokenStream(adaptor,"token IN");
 16543  7004 
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 16544  6948 
         RewriteRuleTokenStream stream_NOT_EQUAL=new RewriteRuleTokenStream(adaptor,"token NOT_EQUAL");
 16545  6948 
         RewriteRuleTokenStream stream_GREATER_EQUAL=new RewriteRuleTokenStream(adaptor,"token GREATER_EQUAL");
 16546  6948 
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 16547  6948 
         RewriteRuleTokenStream stream_LESS=new RewriteRuleTokenStream(adaptor,"token LESS");
 16548  6948 
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 16549  6948 
         RewriteRuleSubtreeStream stream_numericExpression=new RewriteRuleSubtreeStream(adaptor,"rule numericExpression");
 16550  36 
         try {
 16551  36 
             // com\\googlecode\\sparkleg\\Sparql.g:524:5: ( (n1= numericExpression -> $n1) ( ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) ) | ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) ) | ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) ) | ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) ) | ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) ) | ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? )
 16552   
             // com\\googlecode\\sparkleg\\Sparql.g:524:7: (n1= numericExpression -> $n1) ( ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) ) | ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) ) | ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) ) | ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) ) | ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) ) | ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16553   
             {
 16554  36 
             // com\\googlecode\\sparkleg\\Sparql.g:524:7: (n1= numericExpression -> $n1)
 16555  36 
             // com\\googlecode\\sparkleg\\Sparql.g:524:8: n1= numericExpression
 16556   
             {
 16557  6984 
             pushFollow(FOLLOW_numericExpression_in_relationalExpression4262);
 16558  6948 
             n1=numericExpression();
 16559  36 
 
 16560  6948 
             state._fsp--;
 16561   
 
 16562  6948 
             stream_numericExpression.add(n1.getTree());
 16563   
 
 16564   
             // AST REWRITE
 16565   
             // elements: n1
 16566   
             // token labels:
 16567   
             // rule labels: n1, retval
 16568  36 
             // token list labels:
 16569  36 
             // rule list labels:
 16570  36 
             // wildcard labels:
 16571  6948 
             retval.tree = root_0;
 16572  6984 
             RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 16573  6948 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16574   
 
 16575  6948 
             root_0 = (Object)adaptor.nil();
 16576   
             // 524:29: -> $n1
 16577  36 
             {
 16578  6984 
                 adaptor.addChild(root_0, stream_n1.nextTree());
 16579   
 
 16580   
             }
 16581   
 
 16582  36 
 
 16583  6948 
             retval.tree = root_0;
 16584  36 
 
 16585   
             }
 16586  36 
 
 16587   
 
 16588   
             // com\\googlecode\\sparkleg\\Sparql.g:524:37: ( ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) ) | ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) ) | ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) ) | ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) ) | ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) ) | ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16589  6948 
             int alt117=9;
 16590  6948 
             switch ( input.LA(1) ) {
 16591   
                 case EQUAL:
 16592  36 
                     {
 16593  1096 
                     alt117=1;
 16594   
                     }
 16595  1096 
                     break;
 16596   
                 case NOT_EQUAL:
 16597   
                     {
 16598  260 
                     alt117=2;
 16599   
                     }
 16600  224 
                     break;
 16601   
                 case LESS:
 16602   
                     {
 16603  144 
                     alt117=3;
 16604   
                     }
 16605  180 
                     break;
 16606  36 
                 case GREATER:
 16607   
                     {
 16608  144 
                     alt117=4;
 16609  36 
                     }
 16610  180 
                     break;
 16611   
                 case LESS_EQUAL:
 16612  36 
                     {
 16613  16 
                     alt117=5;
 16614  36 
                     }
 16615  16 
                     break;
 16616   
                 case GREATER_EQUAL:
 16617   
                     {
 16618  24 
                     alt117=6;
 16619   
                     }
 16620  24 
                     break;
 16621   
                 case IN:
 16622   
                     {
 16623  52 
                     alt117=7;
 16624  36 
                     }
 16625  52 
                     break;
 16626   
                 case NOT:
 16627  36 
                     {
 16628  16 
                     alt117=8;
 16629   
                     }
 16630   
                     break;
 16631   
             }
 16632  36 
 
 16633  6984 
             switch (alt117) {
 16634   
                 case 1 :
 16635   
                     // com\\googlecode\\sparkleg\\Sparql.g:524:38: ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) )
 16636   
                     {
 16637  36 
                     // com\\googlecode\\sparkleg\\Sparql.g:524:38: ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) )
 16638   
                     // com\\googlecode\\sparkleg\\Sparql.g:524:39: '=' n2= numericExpression
 16639  36 
                     {
 16640  1096 
                     char_literal355=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_relationalExpression4272);
 16641  1132 
                     stream_EQUAL.add(char_literal355);
 16642   
 
 16643   
 
 16644  1096 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4276);
 16645  1096 
                     n2=numericExpression();
 16646   
 
 16647  1132 
                     state._fsp--;
 16648   
 
 16649  1096 
                     stream_numericExpression.add(n2.getTree());
 16650   
 
 16651   
                     // AST REWRITE
 16652   
                     // elements: relationalExpression, EQUAL, n2
 16653  36 
                     // token labels:
 16654   
                     // rule labels: retval, n2
 16655   
                     // token list labels:
 16656   
                     // rule list labels:
 16657   
                     // wildcard labels:
 16658  1096 
                     retval.tree = root_0;
 16659  1096 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16660  1100 
                     RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 16661  4 
 
 16662  1096 
                     root_0 = (Object)adaptor.nil();
 16663   
                     // 524:64: -> ^( '=' $relationalExpression $n2)
 16664  4 
                     {
 16665  4 
                         // com\\googlecode\\sparkleg\\Sparql.g:524:67: ^( '=' $relationalExpression $n2)
 16666   
                         {
 16667  1100 
                         Object root_1 = (Object)adaptor.nil();
 16668  1096 
                         root_1 = (Object)adaptor.becomeRoot(
 16669  4 
                         stream_EQUAL.nextNode()
 16670   
                         , root_1);
 16671   
 
 16672  1096 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16673   
 
 16674  1096 
                         adaptor.addChild(root_1, stream_n2.nextTree());
 16675   
 
 16676  1096 
                         adaptor.addChild(root_0, root_1);
 16677   
                         }
 16678  4 
 
 16679  4 
                     }
 16680  4 
 
 16681   
 
 16682  1100 
                     retval.tree = root_0;
 16683   
 
 16684   
                     }
 16685   
 
 16686   
 
 16687  4 
                     }
 16688  1100 
                     break;
 16689   
                 case 2 :
 16690   
                     // com\\googlecode\\sparkleg\\Sparql.g:525:39: ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) )
 16691   
                     {
 16692  4 
                     // com\\googlecode\\sparkleg\\Sparql.g:525:39: ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) )
 16693   
                     // com\\googlecode\\sparkleg\\Sparql.g:525:40: '!=' n3= numericExpression
 16694  4 
                     {
 16695  224 
                     string_literal356=(Token)match(input,NOT_EQUAL,FOLLOW_NOT_EQUAL_in_relationalExpression4333);
 16696  228 
                     stream_NOT_EQUAL.add(string_literal356);
 16697   
 
 16698   
 
 16699  224 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4337);
 16700  224 
                     n3=numericExpression();
 16701   
 
 16702  228 
                     state._fsp--;
 16703   
 
 16704  224 
                     stream_numericExpression.add(n3.getTree());
 16705   
 
 16706   
                     // AST REWRITE
 16707   
                     // elements: NOT_EQUAL, relationalExpression, n3
 16708  4 
                     // token labels:
 16709   
                     // rule labels: retval, n3
 16710   
                     // token list labels:
 16711   
                     // rule list labels:
 16712   
                     // wildcard labels:
 16713  224 
                     retval.tree = root_0;
 16714  224 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16715  230 
                     RewriteRuleSubtreeStream stream_n3=new RewriteRuleSubtreeStream(adaptor,"rule n3",n3!=null?n3.tree:null);
 16716  6 
 
 16717  224 
                     root_0 = (Object)adaptor.nil();
 16718   
                     // 525:66: -> ^( '!=' $relationalExpression $n3)
 16719  6 
                     {
 16720  6 
                         // com\\googlecode\\sparkleg\\Sparql.g:525:69: ^( '!=' $relationalExpression $n3)
 16721   
                         {
 16722  230 
                         Object root_1 = (Object)adaptor.nil();
 16723  224 
                         root_1 = (Object)adaptor.becomeRoot(
 16724  6 
                         stream_NOT_EQUAL.nextNode()
 16725   
                         , root_1);
 16726   
 
 16727  224 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16728   
 
 16729  224 
                         adaptor.addChild(root_1, stream_n3.nextTree());
 16730   
 
 16731  224 
                         adaptor.addChild(root_0, root_1);
 16732   
                         }
 16733  6 
 
 16734  6 
                     }
 16735  6 
 
 16736   
 
 16737  230 
                     retval.tree = root_0;
 16738   
 
 16739   
                     }
 16740   
 
 16741   
 
 16742  6 
                     }
 16743  230 
                     break;
 16744   
                 case 3 :
 16745   
                     // com\\googlecode\\sparkleg\\Sparql.g:526:39: ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) )
 16746   
                     {
 16747  6 
                     // com\\googlecode\\sparkleg\\Sparql.g:526:39: ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) )
 16748   
                     // com\\googlecode\\sparkleg\\Sparql.g:526:40: '<' n4= numericExpression
 16749  6 
                     {
 16750  144 
                     char_literal357=(Token)match(input,LESS,FOLLOW_LESS_in_relationalExpression4392);
 16751  150 
                     stream_LESS.add(char_literal357);
 16752   
 
 16753   
 
 16754  144 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4396);
 16755  144 
                     n4=numericExpression();
 16756   
 
 16757  150 
                     state._fsp--;
 16758   
 
 16759  144 
                     stream_numericExpression.add(n4.getTree());
 16760   
 
 16761   
                     // AST REWRITE
 16762   
                     // elements: relationalExpression, LESS, n4
 16763  6 
                     // token labels:
 16764   
                     // rule labels: retval, n4
 16765   
                     // token list labels:
 16766   
                     // rule list labels:
 16767   
                     // wildcard labels:
 16768  144 
                     retval.tree = root_0;
 16769  144 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16770  148 
                     RewriteRuleSubtreeStream stream_n4=new RewriteRuleSubtreeStream(adaptor,"rule n4",n4!=null?n4.tree:null);
 16771  4 
 
 16772  144 
                     root_0 = (Object)adaptor.nil();
 16773   
                     // 526:65: -> ^( '<' $relationalExpression $n4)
 16774  4 
                     {
 16775  4 
                         // com\\googlecode\\sparkleg\\Sparql.g:526:68: ^( '<' $relationalExpression $n4)
 16776   
                         {
 16777  148 
                         Object root_1 = (Object)adaptor.nil();
 16778  144 
                         root_1 = (Object)adaptor.becomeRoot(
 16779  4 
                         stream_LESS.nextNode()
 16780   
                         , root_1);
 16781   
 
 16782  144 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16783   
 
 16784  144 
                         adaptor.addChild(root_1, stream_n4.nextTree());
 16785   
 
 16786  144 
                         adaptor.addChild(root_0, root_1);
 16787   
                         }
 16788  4 
 
 16789  4 
                     }
 16790  4 
 
 16791   
 
 16792  148 
                     retval.tree = root_0;
 16793   
 
 16794   
                     }
 16795   
 
 16796   
 
 16797  4 
                     }
 16798  148 
                     break;
 16799   
                 case 4 :
 16800   
                     // com\\googlecode\\sparkleg\\Sparql.g:527:39: ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) )
 16801   
                     {
 16802  4 
                     // com\\googlecode\\sparkleg\\Sparql.g:527:39: ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) )
 16803   
                     // com\\googlecode\\sparkleg\\Sparql.g:527:40: '>' n5= numericExpression
 16804  4 
                     {
 16805  144 
                     char_literal358=(Token)match(input,GREATER,FOLLOW_GREATER_in_relationalExpression4451);
 16806  148 
                     stream_GREATER.add(char_literal358);
 16807   
 
 16808   
 
 16809  144 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4455);
 16810  144 
                     n5=numericExpression();
 16811   
 
 16812  148 
                     state._fsp--;
 16813   
 
 16814  144 
                     stream_numericExpression.add(n5.getTree());
 16815   
 
 16816   
                     // AST REWRITE
 16817   
                     // elements: relationalExpression, GREATER, n5
 16818  4 
                     // token labels:
 16819   
                     // rule labels: retval, n5
 16820   
                     // token list labels:
 16821   
                     // rule list labels:
 16822   
                     // wildcard labels:
 16823  144 
                     retval.tree = root_0;
 16824  144 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16825  148 
                     RewriteRuleSubtreeStream stream_n5=new RewriteRuleSubtreeStream(adaptor,"rule n5",n5!=null?n5.tree:null);
 16826  4 
 
 16827  144 
                     root_0 = (Object)adaptor.nil();
 16828   
                     // 527:65: -> ^( '>' $relationalExpression $n5)
 16829  4 
                     {
 16830  4 
                         // com\\googlecode\\sparkleg\\Sparql.g:527:68: ^( '>' $relationalExpression $n5)
 16831   
                         {
 16832  144 
                         Object root_1 = (Object)adaptor.nil();
 16833  148 
                         root_1 = (Object)adaptor.becomeRoot(
 16834  4 
                         stream_GREATER.nextNode()
 16835   
                         , root_1);
 16836  4 
 
 16837  144 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16838  4 
 
 16839  144 
                         adaptor.addChild(root_1, stream_n5.nextTree());
 16840   
 
 16841  144 
                         adaptor.addChild(root_0, root_1);
 16842   
                         }
 16843   
 
 16844   
                     }
 16845   
 
 16846   
 
 16847  148 
                     retval.tree = root_0;
 16848  4 
 
 16849  4 
                     }
 16850   
 
 16851  4 
 
 16852   
                     }
 16853  144 
                     break;
 16854   
                 case 5 :
 16855   
                     // com\\googlecode\\sparkleg\\Sparql.g:528:39: ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) )
 16856  4 
                     {
 16857  4 
                     // com\\googlecode\\sparkleg\\Sparql.g:528:39: ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) )
 16858   
                     // com\\googlecode\\sparkleg\\Sparql.g:528:40: '<=' n6= numericExpression
 16859   
                     {
 16860  16 
                     string_literal359=(Token)match(input,LESS_EQUAL,FOLLOW_LESS_EQUAL_in_relationalExpression4509);
 16861  20 
                     stream_LESS_EQUAL.add(string_literal359);
 16862   
 
 16863   
 
 16864  16 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4513);
 16865  20 
                     n6=numericExpression();
 16866   
 
 16867  20 
                     state._fsp--;
 16868   
 
 16869  20 
                     stream_numericExpression.add(n6.getTree());
 16870   
 
 16871   
                     // AST REWRITE
 16872   
                     // elements: LESS_EQUAL, n6, relationalExpression
 16873   
                     // token labels:
 16874   
                     // rule labels: retval, n6
 16875  4 
                     // token list labels:
 16876   
                     // rule list labels:
 16877   
                     // wildcard labels:
 16878  16 
                     retval.tree = root_0;
 16879  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16880  16 
                     RewriteRuleSubtreeStream stream_n6=new RewriteRuleSubtreeStream(adaptor,"rule n6",n6!=null?n6.tree:null);
 16881   
 
 16882  16 
                     root_0 = (Object)adaptor.nil();
 16883   
                     // 528:66: -> ^( '<=' $relationalExpression $n6)
 16884   
                     {
 16885   
                         // com\\googlecode\\sparkleg\\Sparql.g:528:69: ^( '<=' $relationalExpression $n6)
 16886   
                         {
 16887  16 
                         Object root_1 = (Object)adaptor.nil();
 16888  1762 
                         root_1 = (Object)adaptor.becomeRoot(
 16889   
                         stream_LESS_EQUAL.nextNode()
 16890   
                         , root_1);
 16891  1746 
 
 16892  1762 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16893   
 
 16894  16 
                         adaptor.addChild(root_1, stream_n6.nextTree());
 16895   
 
 16896  16 
                         adaptor.addChild(root_0, root_1);
 16897   
                         }
 16898   
 
 16899   
                     }
 16900   
 
 16901   
 
 16902  16 
                     retval.tree = root_0;
 16903   
 
 16904  1746 
                     }
 16905  1746 
 
 16906   
 
 16907   
                     }
 16908  16 
                     break;
 16909   
                 case 6 :
 16910  2158 
                     // com\\googlecode\\sparkleg\\Sparql.g:529:39: ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) )
 16911   
                     {
 16912  2158 
                     // com\\googlecode\\sparkleg\\Sparql.g:529:39: ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) )
 16913   
                     // com\\googlecode\\sparkleg\\Sparql.g:529:40: '>=' n7= numericExpression
 16914   
                     {
 16915  24 
                     string_literal360=(Token)match(input,GREATER_EQUAL,FOLLOW_GREATER_EQUAL_in_relationalExpression4567);
 16916  24 
                     stream_GREATER_EQUAL.add(string_literal360);
 16917   
 
 16918   
 
 16919  2182 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4571);
 16920  2182 
                     n7=numericExpression();
 16921   
 
 16922  24 
                     state._fsp--;
 16923  2158 
 
 16924  24 
                     stream_numericExpression.add(n7.getTree());
 16925  2158 
 
 16926   
                     // AST REWRITE
 16927   
                     // elements: GREATER_EQUAL, n7, relationalExpression
 16928   
                     // token labels:
 16929   
                     // rule labels: retval, n7
 16930   
                     // token list labels:
 16931   
                     // rule list labels:
 16932   
                     // wildcard labels:
 16933  2182 
                     retval.tree = root_0;
 16934  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16935  24 
                     RewriteRuleSubtreeStream stream_n7=new RewriteRuleSubtreeStream(adaptor,"rule n7",n7!=null?n7.tree:null);
 16936  2158 
 
 16937  2182 
                     root_0 = (Object)adaptor.nil();
 16938   
                     // 529:66: -> ^( '>=' $relationalExpression $n7)
 16939  2158 
                     {
 16940   
                         // com\\googlecode\\sparkleg\\Sparql.g:529:69: ^( '>=' $relationalExpression $n7)
 16941  2158 
                         {
 16942  24 
                         Object root_1 = (Object)adaptor.nil();
 16943  24 
                         root_1 = (Object)adaptor.becomeRoot(
 16944   
                         stream_GREATER_EQUAL.nextNode()
 16945  2158 
                         , root_1);
 16946   
 
 16947  24 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16948  2158 
 
 16949  2182 
                         adaptor.addChild(root_1, stream_n7.nextTree());
 16950   
 
 16951  24 
                         adaptor.addChild(root_0, root_1);
 16952   
                         }
 16953   
 
 16954   
                     }
 16955   
 
 16956   
 
 16957  24 
                     retval.tree = root_0;
 16958   
 
 16959   
                     }
 16960   
 
 16961  2158 
 
 16962  2158 
                     }
 16963  24 
                     break;
 16964   
                 case 7 :
 16965   
                     // com\\googlecode\\sparkleg\\Sparql.g:530:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16966   
                     {
 16967  2158 
                     // com\\googlecode\\sparkleg\\Sparql.g:530:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16968   
                     // com\\googlecode\\sparkleg\\Sparql.g:530:40: IN l2= expressionList
 16969  2158 
                     {
 16970  16 
                     IN361=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4627);
 16971  16 
                     stream_IN.add(IN361);
 16972   
 
 16973   
 
 16974  16 
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4631);
 16975  16 
                     l2=expressionList();
 16976  2158 
 
 16977  2174 
                     state._fsp--;
 16978   
 
 16979  16 
                     stream_expressionList.add(l2.getTree());
 16980  2158 
 
 16981   
                     // AST REWRITE
 16982  2158 
                     // elements: l2, IN, relationalExpression
 16983  2158 
                     // token labels:
 16984  2158 
                     // rule labels: retval, l2
 16985   
                     // token list labels:
 16986  2158 
                     // rule list labels:
 16987   
                     // wildcard labels:
 16988  2174 
                     retval.tree = root_0;
 16989  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16990  2174 
                     RewriteRuleSubtreeStream stream_l2=new RewriteRuleSubtreeStream(adaptor,"rule l2",l2!=null?l2.tree:null);
 16991   
 
 16992  2174 
                     root_0 = (Object)adaptor.nil();
 16993   
                     // 530:61: -> ^( IN $relationalExpression $l2)
 16994  2158 
                     {
 16995   
                         // com\\googlecode\\sparkleg\\Sparql.g:530:64: ^( IN $relationalExpression $l2)
 16996   
                         {
 16997  2174 
                         Object root_1 = (Object)adaptor.nil();
 16998  2174 
                         root_1 = (Object)adaptor.becomeRoot(
 16999  2158 
                         stream_IN.nextNode()
 17000  2158 
                         , root_1);
 17001  2158 
 
 17002  2174 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 17003  2158 
 
 17004  2174 
                         adaptor.addChild(root_1, stream_l2.nextTree());
 17005  2158 
 
 17006  16 
                         adaptor.addChild(root_0, root_1);
 17007   
                         }
 17008   
 
 17009   
                     }
 17010   
 
 17011   
 
 17012  16 
                     retval.tree = root_0;
 17013  2158 
 
 17014  2158 
                     }
 17015   
 
 17016  2158 
 
 17017   
                     }
 17018  2174 
                     break;
 17019   
                 case 8 :
 17020   
                     // com\\googlecode\\sparkleg\\Sparql.g:531:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 17021   
                     {
 17022   
                     // com\\googlecode\\sparkleg\\Sparql.g:531:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 17023   
                     // com\\googlecode\\sparkleg\\Sparql.g:531:40: NOT IN l3= expressionList
 17024   
                     {
 17025  16 
                     NOT362=(Token)match(input,NOT,FOLLOW_NOT_in_relationalExpression4685);
 17026  16 
                     stream_NOT.add(NOT362);
 17027  2158 
 
 17028  2158 
 
 17029  2174 
                     IN363=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4687);
 17030  16 
                     stream_IN.add(IN363);
 17031  2158 
 
 17032   
 
 17033  16 
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4691);
 17034  2174 
                     l3=expressionList();
 17035   
 
 17036  16 
                     state._fsp--;
 17037   
 
 17038  16 
                     stream_expressionList.add(l3.getTree());
 17039  2158 
 
 17040   
                     // AST REWRITE
 17041   
                     // elements: IN, relationalExpression, l3, NOT
 17042   
                     // token labels:
 17043   
                     // rule labels: retval, l3
 17044   
                     // token list labels:
 17045   
                     // rule list labels:
 17046   
                     // wildcard labels:
 17047  2320 
                     retval.tree = root_0;
 17048  2320 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17049  16 
                     RewriteRuleSubtreeStream stream_l3=new RewriteRuleSubtreeStream(adaptor,"rule l3",l3!=null?l3.tree:null);
 17050   
 
 17051  16 
                     root_0 = (Object)adaptor.nil();
 17052  106 
                     // 531:65: -> ^( NOT IN $relationalExpression $l3)
 17053   
                     {
 17054  106 
                         // com\\googlecode\\sparkleg\\Sparql.g:531:68: ^( NOT IN $relationalExpression $l3)
 17055   
                         {
 17056  16 
                         Object root_1 = (Object)adaptor.nil();
 17057  16 
                         root_1 = (Object)adaptor.becomeRoot(
 17058   
                         stream_NOT.nextNode()
 17059   
                         , root_1);
 17060   
 
 17061  16 
                         adaptor.addChild(root_1,
 17062  40 
                         stream_IN.nextNode()
 17063   
                         );
 17064   
 
 17065  16 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 17066   
 
 17067  16 
                         adaptor.addChild(root_1, stream_l3.nextTree());
 17068  2304 
 
 17069  16 
                         adaptor.addChild(root_0, root_1);
 17070   
                         }
 17071   
 
 17072   
                     }
 17073   
 
 17074   
 
 17075  122 
                     retval.tree = root_0;
 17076  106 
 
 17077   
                     }
 17078  106 
 
 17079   
 
 17080  106 
                     }
 17081   
                     break;
 17082  106 
 
 17083  106 
             }
 17084   
 
 17085  106 
 
 17086   
             }
 17087  106 
 
 17088  6948 
             retval.stop = input.LT(-1);
 17089   
 
 17090   
 
 17091  6948 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17092  6948 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17093   
 
 17094   
         }
 17095  0 
         catch (RecognitionException re) {
 17096  106 
             reportError(re);
 17097  106 
             recover(input,re);
 17098  106 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17099   
 
 17100  106 
         }
 17101   
 
 17102  0 
         finally {
 17103   
                 // do for sure before leaving
 17104  6948 
         }
 17105  7054 
         return retval;
 17106  106 
     }
 17107   
     // $ANTLR end "relationalExpression"
 17108  106 
 
 17109   
 
 17110  106 
     public static class numericExpression_return extends ParserRuleReturnScope {
 17111   
         Object tree;
 17112  106 
         public Object getTree() { return tree; }
 17113   
     };
 17114   
 
 17115   
 
 17116   
     // $ANTLR start "numericExpression"
 17117   
     // com\\googlecode\\sparkleg\\Sparql.g:534:1: numericExpression : additiveExpression ;
 17118  106 
     public final SparqlParser.numericExpression_return numericExpression() throws RecognitionException {
 17119  8596 
         SparqlParser.numericExpression_return retval = new SparqlParser.numericExpression_return();
 17120  8596 
         retval.start = input.LT(1);
 17121   
 
 17122   
 
 17123  8596 
         Object root_0 = null;
 17124  106 
 
 17125  8596 
         SparqlParser.additiveExpression_return additiveExpression364 =null;
 17126   
 
 17127   
 
 17128   
 
 17129  40 
         try {
 17130  40 
             // com\\googlecode\\sparkleg\\Sparql.g:535:5: ( additiveExpression )
 17131   
             // com\\googlecode\\sparkleg\\Sparql.g:535:7: additiveExpression
 17132   
             {
 17133  8596 
             root_0 = (Object)adaptor.nil();
 17134   
 
 17135  40 
 
 17136  8596 
             pushFollow(FOLLOW_additiveExpression_in_numericExpression4725);
 17137  8636 
             additiveExpression364=additiveExpression();
 17138   
 
 17139  8596 
             state._fsp--;
 17140   
 
 17141  8596 
             adaptor.addChild(root_0, additiveExpression364.getTree());
 17142   
 
 17143   
             }
 17144   
 
 17145  8596 
             retval.stop = input.LT(-1);
 17146   
 
 17147   
 
 17148  8596 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17149  8596 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17150   
 
 17151   
         }
 17152  0 
         catch (RecognitionException re) {
 17153  40 
             reportError(re);
 17154  0 
             recover(input,re);
 17155  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17156   
 
 17157  40 
         }
 17158  40 
 
 17159  0 
         finally {
 17160  40 
                 // do for sure before leaving
 17161  8596 
         }
 17162  8636 
         return retval;
 17163   
     }
 17164   
     // $ANTLR end "numericExpression"
 17165   
 
 17166   
 
 17167  8596 
     public static class additiveExpression_return extends ParserRuleReturnScope {
 17168   
         Object tree;
 17169  8596 
         public Object getTree() { return tree; }
 17170   
     };
 17171  40 
 
 17172  40 
 
 17173  40 
     // $ANTLR start "additiveExpression"
 17174   
     // com\\googlecode\\sparkleg\\Sparql.g:538:1: additiveExpression : (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )? )* ;
 17175  40 
     public final SparqlParser.additiveExpression_return additiveExpression() throws RecognitionException {
 17176  8596 
         SparqlParser.additiveExpression_return retval = new SparqlParser.additiveExpression_return();
 17177  8596 
         retval.start = input.LT(1);
 17178   
 
 17179   
 
 17180  8636 
         Object root_0 = null;
 17181  40 
 
 17182  8596 
         Token char_literal366=null;
 17183  8596 
         Token char_literal367=null;
 17184  8596 
         SparqlParser.multiplicativeExpression_return m1 =null;
 17185  40 
 
 17186  8596 
         SparqlParser.multiplicativeExpression_return m2 =null;
 17187  40 
 
 17188  8596 
         SparqlParser.numericLiteralPositive_return n1 =null;
 17189  40 
 
 17190  8596 
         SparqlParser.numericLiteralNegative_return n2 =null;
 17191   
 
 17192  8596 
         SparqlParser.unaryExpression_return u2 =null;
 17193   
 
 17194  8596 
         SparqlParser.additiveOperator_return additiveOperator365 =null;
 17195  40 
 
 17196   
 
 17197  8596 
         Object char_literal366_tree=null;
 17198  8636 
         Object char_literal367_tree=null;
 17199  8596 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 17200  8596 
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 17201  8596 
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 17202  8596 
         RewriteRuleSubtreeStream stream_numericLiteralNegative=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralNegative");
 17203  8596 
         RewriteRuleSubtreeStream stream_numericLiteralPositive=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralPositive");
 17204  8596 
         RewriteRuleSubtreeStream stream_additiveOperator=new RewriteRuleSubtreeStream(adaptor,"rule additiveOperator");
 17205  8596 
         RewriteRuleSubtreeStream stream_multiplicativeExpression=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeExpression");
 17206   
         try {
 17207   
             // com\\googlecode\\sparkleg\\Sparql.g:539:5: ( (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )? )* )
 17208   
             // com\\googlecode\\sparkleg\\Sparql.g:539:7: (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )? )*
 17209   
             {
 17210   
             // com\\googlecode\\sparkleg\\Sparql.g:539:7: (m1= multiplicativeExpression -> $m1)
 17211   
             // com\\googlecode\\sparkleg\\Sparql.g:539:8: m1= multiplicativeExpression
 17212   
             {
 17213  8596 
             pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4745);
 17214  8596 
             m1=multiplicativeExpression();
 17215   
 
 17216  8596 
             state._fsp--;
 17217   
 
 17218  8596 
             stream_multiplicativeExpression.add(m1.getTree());
 17219   
 
 17220   
             // AST REWRITE
 17221   
             // elements: m1
 17222   
             // token labels:
 17223   
             // rule labels: retval, m1
 17224   
             // token list labels:
 17225   
             // rule list labels:
 17226   
             // wildcard labels:
 17227  8596 
             retval.tree = root_0;
 17228  8596 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17229  8596 
             RewriteRuleSubtreeStream stream_m1=new RewriteRuleSubtreeStream(adaptor,"rule m1",m1!=null?m1.tree:null);
 17230   
 
 17231  8596 
             root_0 = (Object)adaptor.nil();
 17232   
             // 539:36: -> $m1
 17233   
             {
 17234  8596 
                 adaptor.addChild(root_0, stream_m1.nextTree());
 17235   
 
 17236   
             }
 17237   
 
 17238   
 
 17239  8596 
             retval.tree = root_0;
 17240   
 
 17241   
             }
 17242   
 
 17243   
 
 17244   
             // com\\googlecode\\sparkleg\\Sparql.g:539:44: ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )? )*
 17245   
             loop120:
 17246   
             do {
 17247  9180 
                 int alt120=3;
 17248  9180 
                 switch ( input.LA(1) ) {
 17249  40 
                 case MINUS:
 17250  40 
                 case PLUS:
 17251   
                     {
 17252  484 
                     alt120=1;
 17253   
                     }
 17254  484 
                     break;
 17255   
                 case DECIMAL_NEGATIVE:
 17256   
                 case DECIMAL_POSITIVE:
 17257   
                 case DOUBLE_NEGATIVE:
 17258   
                 case DOUBLE_POSITIVE:
 17259   
                 case INTEGER_NEGATIVE:
 17260   
                 case INTEGER_POSITIVE:
 17261   
                     {
 17262  100 
                     alt120=2;
 17263  40 
                     }
 17264   
                     break;
 17265   
 
 17266   
                 }
 17267   
 
 17268  9180 
                 switch (alt120) {
 17269   
                     case 1 :
 17270   
                         // com\\googlecode\\sparkleg\\Sparql.g:539:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 17271   
                         {
 17272   
                         // com\\googlecode\\sparkleg\\Sparql.g:539:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 17273   
                         // com\\googlecode\\sparkleg\\Sparql.g:539:46: additiveOperator m2= multiplicativeExpression
 17274   
                         {
 17275  484 
                         pushFollow(FOLLOW_additiveOperator_in_additiveExpression4755);
 17276  484 
                         additiveOperator365=additiveOperator();
 17277   
 
 17278  484 
                         state._fsp--;
 17279   
 
 17280  484 
                         stream_additiveOperator.add(additiveOperator365.getTree());
 17281   
 
 17282  484 
                         pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4759);
 17283  484 
                         m2=multiplicativeExpression();
 17284   
 
 17285  484 
                         state._fsp--;
 17286   
 
 17287  484 
                         stream_multiplicativeExpression.add(m2.getTree());
 17288   
 
 17289   
                         // AST REWRITE
 17290   
                         // elements: additiveOperator, additiveExpression, m2
 17291   
                         // token labels:
 17292   
                         // rule labels: retval, m2
 17293   
                         // token list labels:
 17294   
                         // rule list labels:
 17295   
                         // wildcard labels:
 17296  484 
                         retval.tree = root_0;
 17297  484 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17298  484 
                         RewriteRuleSubtreeStream stream_m2=new RewriteRuleSubtreeStream(adaptor,"rule m2",m2!=null?m2.tree:null);
 17299   
 
 17300  484 
                         root_0 = (Object)adaptor.nil();
 17301   
                         // 539:91: -> ^( additiveOperator $additiveExpression $m2)
 17302   
                         {
 17303   
                             // com\\googlecode\\sparkleg\\Sparql.g:539:94: ^( additiveOperator $additiveExpression $m2)
 17304   
                             {
 17305  484 
                             Object root_1 = (Object)adaptor.nil();
 17306  484 
                             root_1 = (Object)adaptor.becomeRoot(stream_additiveOperator.nextNode(), root_1);
 17307   
 
 17308  484 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17309   
 
 17310  484 
                             adaptor.addChild(root_1, stream_m2.nextTree());
 17311   
 
 17312  484 
                             adaptor.addChild(root_0, root_1);
 17313   
                             }
 17314   
 
 17315   
                         }
 17316   
 
 17317   
 
 17318  484 
                         retval.tree = root_0;
 17319   
 
 17320   
                         }
 17321   
 
 17322   
 
 17323   
                         }
 17324  484 
                         break;
 17325   
                     case 2 :
 17326   
                         // com\\googlecode\\sparkleg\\Sparql.g:540:48: (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )?
 17327   
                         {
 17328   
                         // com\\googlecode\\sparkleg\\Sparql.g:540:48: (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) )
 17329  100 
                         int alt118=2;
 17330  100 
                         switch ( input.LA(1) ) {
 17331   
                         case DECIMAL_POSITIVE:
 17332   
                         case DOUBLE_POSITIVE:
 17333   
                         case INTEGER_POSITIVE:
 17334   
                             {
 17335  100 
                             alt118=1;
 17336   
                             }
 17337  100 
                             break;
 17338   
                         case DECIMAL_NEGATIVE:
 17339   
                         case DOUBLE_NEGATIVE:
 17340   
                         case INTEGER_NEGATIVE:
 17341   
                             {
 17342  0 
                             alt118=2;
 17343   
                             }
 17344  0 
                             break;
 17345   
                         default:
 17346  0 
                             NoViableAltException nvae =
 17347   
                                 new NoViableAltException("", 118, 0, input);
 17348   
 
 17349  0 
                             throw nvae;
 17350   
 
 17351   
                         }
 17352   
 
 17353  100 
                         switch (alt118) {
 17354   
                             case 1 :
 17355   
                                 // com\\googlecode\\sparkleg\\Sparql.g:540:49: n1= numericLiteralPositive
 17356   
                                 {
 17357  100 
                                 pushFollow(FOLLOW_numericLiteralPositive_in_additiveExpression4826);
 17358  100 
                                 n1=numericLiteralPositive();
 17359   
 
 17360  100 
                                 state._fsp--;
 17361   
 
 17362  100 
                                 stream_numericLiteralPositive.add(n1.getTree());
 17363   
 
 17364   
                                 // AST REWRITE
 17365   
                                 // elements: additiveExpression, PLUS, n1
 17366   
                                 // token labels:
 17367   
                                 // rule labels: n1, retval
 17368   
                                 // token list labels:
 17369   
                                 // rule list labels:
 17370   
                                 // wildcard labels:
 17371  100 
                                 retval.tree = root_0;
 17372  100 
                                 RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 17373  100 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17374   
 
 17375  100 
                                 root_0 = (Object)adaptor.nil();
 17376   
                                 // 540:75: -> ^( '+' $additiveExpression $n1)
 17377   
                                 {
 17378   
                                     // com\\googlecode\\sparkleg\\Sparql.g:540:78: ^( '+' $additiveExpression $n1)
 17379   
                                     {
 17380  100 
                                     Object root_1 = (Object)adaptor.nil();
 17381  100 
                                     root_1 = (Object)adaptor.becomeRoot(
 17382   
                                     (Object)adaptor.create(PLUS, "PLUS")
 17383   
                                     , root_1);
 17384   
 
 17385  100 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17386   
 
 17387  100 
                                     adaptor.addChild(root_1, stream_n1.nextTree());
 17388   
 
 17389  100 
                                     adaptor.addChild(root_0, root_1);
 17390   
                                     }
 17391  40 
 
 17392   
                                 }
 17393   
 
 17394  2158 
 
 17395  100 
                                 retval.tree = root_0;
 17396  146 
 
 17397   
                                 }
 17398  100 
                                 break;
 17399   
                             case 2 :
 17400   
                                 // com\\googlecode\\sparkleg\\Sparql.g:540:111: n2= numericLiteralNegative
 17401  2158 
                                 {
 17402  0 
                                 pushFollow(FOLLOW_numericLiteralNegative_in_additiveExpression4844);
 17403  0 
                                 n2=numericLiteralNegative();
 17404  2158 
 
 17405  2158 
                                 state._fsp--;
 17406   
 
 17407  0 
                                 stream_numericLiteralNegative.add(n2.getTree());
 17408   
 
 17409   
                                 // AST REWRITE
 17410   
                                 // elements: PLUS, additiveExpression, n2
 17411   
                                 // token labels:
 17412   
                                 // rule labels: retval, n2
 17413   
                                 // token list labels:
 17414   
                                 // rule list labels:
 17415   
                                 // wildcard labels:
 17416  0 
                                 retval.tree = root_0;
 17417  2158 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17418  2158 
                                 RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 17419   
 
 17420  0 
                                 root_0 = (Object)adaptor.nil();
 17421   
                                 // 540:137: -> ^( '+' $additiveExpression $n2)
 17422   
                                 {
 17423  106 
                                     // com\\googlecode\\sparkleg\\Sparql.g:540:140: ^( '+' $additiveExpression $n2)
 17424   
                                     {
 17425  106 
                                     Object root_1 = (Object)adaptor.nil();
 17426  0 
                                     root_1 = (Object)adaptor.becomeRoot(
 17427   
                                     (Object)adaptor.create(PLUS, "PLUS")
 17428   
                                     , root_1);
 17429   
 
 17430  0 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17431   
 
 17432  106 
                                     adaptor.addChild(root_1, stream_n2.nextTree());
 17433  106 
 
 17434  0 
                                     adaptor.addChild(root_0, root_1);
 17435   
                                     }
 17436  106 
 
 17437   
                                 }
 17438  106 
 
 17439   
 
 17440  106 
                                 retval.tree = root_0;
 17441   
 
 17442   
                                 }
 17443   
                                 break;
 17444   
 
 17445   
                         }
 17446  106 
 
 17447   
 
 17448   
                         // com\\googlecode\\sparkleg\\Sparql.g:541:46: ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )?
 17449  206 
                         int alt119=3;
 17450  100 
                         switch ( input.LA(1) ) {
 17451  106 
                             case ASTERISK:
 17452  106 
                                 {
 17453  106 
                                 alt119=1;
 17454   
                                 }
 17455  0 
                                 break;
 17456  106 
                             case DIVIDE:
 17457   
                                 {
 17458  0 
                                 alt119=2;
 17459   
                                 }
 17460   
                                 break;
 17461   
                         }
 17462   
 
 17463  100 
                         switch (alt119) {
 17464   
                             case 1 :
 17465   
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:47: ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) )
 17466  106 
                                 {
 17467   
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:47: ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) )
 17468   
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:48: ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) )
 17469  106 
                                 {
 17470  106 
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:48: ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) )
 17471   
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:49: '*' u2= unaryExpression
 17472   
                                 {
 17473  0 
                                 char_literal366=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_additiveExpression4908);
 17474  0 
                                 stream_ASTERISK.add(char_literal366);
 17475   
 
 17476   
 
 17477  0 
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4912);
 17478  0 
                                 u2=unaryExpression();
 17479   
 
 17480  0 
                                 state._fsp--;
 17481   
 
 17482  106 
                                 stream_unaryExpression.add(u2.getTree());
 17483  106 
 
 17484   
                                 // AST REWRITE
 17485   
                                 // elements: u2, additiveExpression, ASTERISK
 17486   
                                 // token labels:
 17487   
                                 // rule labels: retval, u2
 17488  2264 
                                 // token list labels:
 17489   
                                 // rule list labels:
 17490  2264 
                                 // wildcard labels:
 17491  0 
                                 retval.tree = root_0;
 17492  0 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17493  0 
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17494   
 
 17495  0 
                                 root_0 = (Object)adaptor.nil();
 17496   
                                 // 541:72: -> ^( '*' $additiveExpression $u2)
 17497  2264 
                                 {
 17498  2264 
                                     // com\\googlecode\\sparkleg\\Sparql.g:541:75: ^( '*' $additiveExpression $u2)
 17499   
                                     {
 17500  0 
                                     Object root_1 = (Object)adaptor.nil();
 17501  2264 
                                     root_1 = (Object)adaptor.becomeRoot(
 17502   
                                     stream_ASTERISK.nextNode()
 17503  2264 
                                     , root_1);
 17504   
 
 17505  2264 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17506   
 
 17507  2264 
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17508   
 
 17509  0 
                                     adaptor.addChild(root_0, root_1);
 17510  2264 
                                     }
 17511  2264 
 
 17512   
                                 }
 17513   
 
 17514   
 
 17515  0 
                                 retval.tree = root_0;
 17516   
 
 17517   
                                 }
 17518   
 
 17519  2264 
 
 17520  2264 
                                 }
 17521   
 
 17522  2264 
 
 17523   
                                 }
 17524  2264 
                                 break;
 17525   
                             case 2 :
 17526   
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:48: ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) )
 17527   
                                 {
 17528   
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:48: ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) )
 17529   
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:49: ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) )
 17530   
                                 {
 17531   
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:49: ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) )
 17532   
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:50: '/' u2= unaryExpression
 17533  2264 
                                 {
 17534  2264 
                                 char_literal367=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_additiveExpression4978);
 17535  2264 
                                 stream_DIVIDE.add(char_literal367);
 17536   
 
 17537  2264 
 
 17538  0 
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4982);
 17539  0 
                                 u2=unaryExpression();
 17540  2264 
 
 17541  0 
                                 state._fsp--;
 17542   
 
 17543  0 
                                 stream_unaryExpression.add(u2.getTree());
 17544   
 
 17545  2264 
                                 // AST REWRITE
 17546   
                                 // elements: u2, DIVIDE, additiveExpression
 17547   
                                 // token labels:
 17548   
                                 // rule labels: retval, u2
 17549   
                                 // token list labels:
 17550   
                                 // rule list labels:
 17551   
                                 // wildcard labels:
 17552  0 
                                 retval.tree = root_0;
 17553  2296 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17554  2296 
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17555   
 
 17556  0 
                                 root_0 = (Object)adaptor.nil();
 17557   
                                 // 542:73: -> ^( '/' $additiveExpression $u2)
 17558  32 
                                 {
 17559   
                                     // com\\googlecode\\sparkleg\\Sparql.g:542:76: ^( '/' $additiveExpression $u2)
 17560   
                                     {
 17561  0 
                                     Object root_1 = (Object)adaptor.nil();
 17562  0 
                                     root_1 = (Object)adaptor.becomeRoot(
 17563   
                                     stream_DIVIDE.nextNode()
 17564  2296 
                                     , root_1);
 17565   
 
 17566  0 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17567   
 
 17568  32 
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17569  32 
 
 17570  0 
                                     adaptor.addChild(root_0, root_1);
 17571  32 
                                     }
 17572   
 
 17573  32 
                                 }
 17574   
 
 17575  32 
 
 17576  32 
                                 retval.tree = root_0;
 17577   
 
 17578  32 
                                 }
 17579   
 
 17580  32 
 
 17581   
                                 }
 17582   
 
 17583   
 
 17584   
                                 }
 17585   
                                 break;
 17586   
 
 17587   
                         }
 17588   
 
 17589  32 
 
 17590  32 
                         }
 17591  132 
                         break;
 17592   
 
 17593  32 
                     default :
 17594  8596 
                         break loop120;
 17595   
                 }
 17596  584 
             } while (true);
 17597   
 
 17598  32 
 
 17599  32 
             }
 17600   
 
 17601  8628 
             retval.stop = input.LT(-1);
 17602   
 
 17603  32 
 
 17604  8596 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17605  8628 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17606   
 
 17607   
         }
 17608  0 
         catch (RecognitionException re) {
 17609  0 
             reportError(re);
 17610  0 
             recover(input,re);
 17611  32 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17612   
 
 17613   
         }
 17614  32 
 
 17615  0 
         finally {
 17616   
                 // do for sure before leaving
 17617  10860 
         }
 17618  8596 
         return retval;
 17619  32 
     }
 17620   
     // $ANTLR end "additiveExpression"
 17621   
 
 17622   
 
 17623  484 
     public static class additiveOperator_return extends ParserRuleReturnScope {
 17624  2264 
         Object tree;
 17625  484 
         public Object getTree() { return tree; }
 17626   
     };
 17627  2264 
 
 17628  2264 
 
 17629   
     // $ANTLR start "additiveOperator"
 17630   
     // com\\googlecode\\sparkleg\\Sparql.g:545:1: additiveOperator : ( '+' | '-' );
 17631   
     public final SparqlParser.additiveOperator_return additiveOperator() throws RecognitionException {
 17632  484 
         SparqlParser.additiveOperator_return retval = new SparqlParser.additiveOperator_return();
 17633  484 
         retval.start = input.LT(1);
 17634   
 
 17635   
 
 17636  484 
         Object root_0 = null;
 17637   
 
 17638  484 
         Token set368=null;
 17639   
 
 17640  2748 
         Object set368_tree=null;
 17641  2264 
 
 17642   
         try {
 17643   
             // com\\googlecode\\sparkleg\\Sparql.g:546:5: ( '+' | '-' )
 17644   
             // com\\googlecode\\sparkleg\\Sparql.g:
 17645   
             {
 17646  484 
             root_0 = (Object)adaptor.nil();
 17647   
 
 17648  32 
 
 17649  484 
             set368=(Token)input.LT(1);
 17650   
 
 17651  484 
             if ( input.LA(1)==MINUS||input.LA(1)==PLUS ) {
 17652  484 
                 input.consume();
 17653  484 
                 adaptor.addChild(root_0,
 17654   
                 (Object)adaptor.create(set368)
 17655  32 
                 );
 17656  516 
                 state.errorRecovery=false;
 17657   
             }
 17658   
             else {
 17659  32 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17660  0 
                 throw mse;
 17661  32 
             }
 17662   
 
 17663  32 
 
 17664   
             }
 17665   
 
 17666  484 
             retval.stop = input.LT(-1);
 17667   
 
 17668   
 
 17669  516 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17670  484 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17671   
 
 17672  32 
         }
 17673  0 
         catch (RecognitionException re) {
 17674  32 
             reportError(re);
 17675  32 
             recover(input,re);
 17676  32 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17677   
 
 17678   
         }
 17679  32 
 
 17680  0 
         finally {
 17681   
                 // do for sure before leaving
 17682  484 
         }
 17683  484 
         return retval;
 17684   
     }
 17685   
     // $ANTLR end "additiveOperator"
 17686   
 
 17687   
 
 17688  9080 
     public static class multiplicativeExpression_return extends ParserRuleReturnScope {
 17689  32 
         Object tree;
 17690  9080 
         public Object getTree() { return tree; }
 17691   
     };
 17692  32 
 
 17693  32 
 
 17694   
     // $ANTLR start "multiplicativeExpression"
 17695   
     // com\\googlecode\\sparkleg\\Sparql.g:549:1: multiplicativeExpression : (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* ;
 17696   
     public final SparqlParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
 17697  9080 
         SparqlParser.multiplicativeExpression_return retval = new SparqlParser.multiplicativeExpression_return();
 17698  9080 
         retval.start = input.LT(1);
 17699   
 
 17700   
 
 17701  9080 
         Object root_0 = null;
 17702   
 
 17703  9080 
         SparqlParser.unaryExpression_return u1 =null;
 17704   
 
 17705  9112 
         SparqlParser.unaryExpression_return u2 =null;
 17706  32 
 
 17707  9080 
         SparqlParser.multiplicativeOperator_return multiplicativeOperator369 =null;
 17708   
 
 17709   
 
 17710  9080 
         RewriteRuleSubtreeStream stream_multiplicativeOperator=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeOperator");
 17711  9080 
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 17712   
         try {
 17713  2296 
             // com\\googlecode\\sparkleg\\Sparql.g:550:5: ( (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* )
 17714   
             // com\\googlecode\\sparkleg\\Sparql.g:550:7: (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17715   
             {
 17716   
             // com\\googlecode\\sparkleg\\Sparql.g:550:7: (u1= unaryExpression -> $u1)
 17717   
             // com\\googlecode\\sparkleg\\Sparql.g:550:8: u1= unaryExpression
 17718   
             {
 17719  9080 
             pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression5048);
 17720  11376 
             u1=unaryExpression();
 17721  2296 
 
 17722  9080 
             state._fsp--;
 17723   
 
 17724  11376 
             stream_unaryExpression.add(u1.getTree());
 17725   
 
 17726  2296 
             // AST REWRITE
 17727  2296 
             // elements: u1
 17728  2296 
             // token labels:
 17729  2296 
             // rule labels: retval, u1
 17730   
             // token list labels:
 17731  2296 
             // rule list labels:
 17732   
             // wildcard labels:
 17733  11376 
             retval.tree = root_0;
 17734  9080 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17735  11376 
             RewriteRuleSubtreeStream stream_u1=new RewriteRuleSubtreeStream(adaptor,"rule u1",u1!=null?u1.tree:null);
 17736   
 
 17737  9080 
             root_0 = (Object)adaptor.nil();
 17738  2296 
             // 550:27: -> $u1
 17739  2296 
             {
 17740  11376 
                 adaptor.addChild(root_0, stream_u1.nextTree());
 17741  2296 
 
 17742  2296 
             }
 17743  2296 
 
 17744  2296 
 
 17745  9080 
             retval.tree = root_0;
 17746   
 
 17747  2296 
             }
 17748  2296 
 
 17749   
 
 17750   
             // com\\googlecode\\sparkleg\\Sparql.g:550:35: ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17751  38 
             loop121:
 17752   
             do {
 17753  9246 
                 int alt121=2;
 17754  9208 
                 switch ( input.LA(1) ) {
 17755   
                 case ASTERISK:
 17756   
                 case DIVIDE:
 17757   
                     {
 17758  128 
                     alt121=1;
 17759   
                     }
 17760   
                     break;
 17761  2 
 
 17762   
                 }
 17763  2 
 
 17764  9208 
                 switch (alt121) {
 17765   
                     case 1 :
 17766   
                         // com\\googlecode\\sparkleg\\Sparql.g:550:36: multiplicativeOperator u2= unaryExpression
 17767   
                         {
 17768  128 
                         pushFollow(FOLLOW_multiplicativeOperator_in_multiplicativeExpression5057);
 17769  128 
                         multiplicativeOperator369=multiplicativeOperator();
 17770   
 
 17771  128 
                         state._fsp--;
 17772   
 
 17773  128 
                         stream_multiplicativeOperator.add(multiplicativeOperator369.getTree());
 17774   
 
 17775  128 
                         pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression5061);
 17776  128 
                         u2=unaryExpression();
 17777   
 
 17778  128 
                         state._fsp--;
 17779   
 
 17780  128 
                         stream_unaryExpression.add(u2.getTree());
 17781   
 
 17782   
                         // AST REWRITE
 17783   
                         // elements: multiplicativeExpression, multiplicativeOperator, u2
 17784   
                         // token labels:
 17785   
                         // rule labels: retval, u2
 17786   
                         // token list labels:
 17787   
                         // rule list labels:
 17788   
                         // wildcard labels:
 17789  128 
                         retval.tree = root_0;
 17790  128 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17791  128 
                         RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17792   
 
 17793  128 
                         root_0 = (Object)adaptor.nil();
 17794   
                         // 550:78: -> ^( multiplicativeOperator $multiplicativeExpression $u2)
 17795   
                         {
 17796   
                             // com\\googlecode\\sparkleg\\Sparql.g:550:81: ^( multiplicativeOperator $multiplicativeExpression $u2)
 17797   
                             {
 17798  128 
                             Object root_1 = (Object)adaptor.nil();
 17799  128 
                             root_1 = (Object)adaptor.becomeRoot(stream_multiplicativeOperator.nextNode(), root_1);
 17800   
 
 17801  128 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17802   
 
 17803  128 
                             adaptor.addChild(root_1, stream_u2.nextTree());
 17804   
 
 17805  128 
                             adaptor.addChild(root_0, root_1);
 17806   
                             }
 17807   
 
 17808   
                         }
 17809   
 
 17810   
 
 17811  128 
                         retval.tree = root_0;
 17812   
 
 17813   
                         }
 17814  128 
                         break;
 17815   
 
 17816   
                     default :
 17817  9080 
                         break loop121;
 17818   
                 }
 17819  128 
             } while (true);
 17820   
 
 17821   
 
 17822   
             }
 17823   
 
 17824  9080 
             retval.stop = input.LT(-1);
 17825   
 
 17826   
 
 17827  9080 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17828  9080 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17829   
 
 17830   
         }
 17831  0 
         catch (RecognitionException re) {
 17832  0 
             reportError(re);
 17833  0 
             recover(input,re);
 17834  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17835   
 
 17836   
         }
 17837   
 
 17838  0 
         finally {
 17839   
                 // do for sure before leaving
 17840  9080 
         }
 17841  9080 
         return retval;
 17842   
     }
 17843   
     // $ANTLR end "multiplicativeExpression"
 17844   
 
 17845  2252 
 
 17846  128 
     public static class multiplicativeOperator_return extends ParserRuleReturnScope {
 17847  2252 
         Object tree;
 17848  128 
         public Object getTree() { return tree; }
 17849  4 
     };
 17850   
 
 17851   
 
 17852  4 
     // $ANTLR start "multiplicativeOperator"
 17853   
     // com\\googlecode\\sparkleg\\Sparql.g:553:1: multiplicativeOperator : ( '*' | '/' );
 17854   
     public final SparqlParser.multiplicativeOperator_return multiplicativeOperator() throws RecognitionException {
 17855  128 
         SparqlParser.multiplicativeOperator_return retval = new SparqlParser.multiplicativeOperator_return();
 17856  2420 
         retval.start = input.LT(1);
 17857   
 
 17858   
 
 17859  128 
         Object root_0 = null;
 17860  38 
 
 17861  166 
         Token set370=null;
 17862   
 
 17863  128 
         Object set370_tree=null;
 17864  38 
 
 17865  38 
         try {
 17866   
             // com\\googlecode\\sparkleg\\Sparql.g:554:5: ( '*' | '/' )
 17867  38 
             // com\\googlecode\\sparkleg\\Sparql.g:
 17868   
             {
 17869  166 
             root_0 = (Object)adaptor.nil();
 17870   
 
 17871   
 
 17872  128 
             set370=(Token)input.LT(1);
 17873   
 
 17874  128 
             if ( input.LA(1)==ASTERISK||input.LA(1)==DIVIDE ) {
 17875  128 
                 input.consume();
 17876  128 
                 adaptor.addChild(root_0,
 17877   
                 (Object)adaptor.create(set370)
 17878  38 
                 );
 17879  166 
                 state.errorRecovery=false;
 17880   
             }
 17881  38 
             else {
 17882  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17883  0 
                 throw mse;
 17884   
             }
 17885   
 
 17886  38 
 
 17887  38 
             }
 17888   
 
 17889  128 
             retval.stop = input.LT(-1);
 17890   
 
 17891  38 
 
 17892  128 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17893  128 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17894   
 
 17895  38 
         }
 17896  0 
         catch (RecognitionException re) {
 17897  38 
             reportError(re);
 17898  0 
             recover(input,re);
 17899  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17900   
 
 17901   
         }
 17902   
 
 17903  38 
         finally {
 17904   
                 // do for sure before leaving
 17905  128 
         }
 17906  166 
         return retval;
 17907   
     }
 17908   
     // $ANTLR end "multiplicativeOperator"
 17909   
 
 17910   
 
 17911  9208 
     public static class unaryExpression_return extends ParserRuleReturnScope {
 17912   
         Object tree;
 17913  9208 
         public Object getTree() { return tree; }
 17914   
     };
 17915   
 
 17916   
 
 17917   
     // $ANTLR start "unaryExpression"
 17918   
     // com\\googlecode\\sparkleg\\Sparql.g:557:1: unaryExpression : ( '!' primaryExpression -> ^( UNARY '!' primaryExpression ) | '+' primaryExpression -> ^( UNARY '+' primaryExpression ) | '-' primaryExpression -> ^( UNARY '-' primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) );
 17919   
     public final SparqlParser.unaryExpression_return unaryExpression() throws RecognitionException {
 17920  9208 
         SparqlParser.unaryExpression_return retval = new SparqlParser.unaryExpression_return();
 17921  9208 
         retval.start = input.LT(1);
 17922   
 
 17923   
 
 17924  9208 
         Object root_0 = null;
 17925   
 
 17926  9208 
         Token char_literal371=null;
 17927  9208 
         Token char_literal373=null;
 17928  9208 
         Token char_literal375=null;
 17929  9208 
         SparqlParser.primaryExpression_return primaryExpression372 =null;
 17930   
 
 17931  9208 
         SparqlParser.primaryExpression_return primaryExpression374 =null;
 17932   
 
 17933  9208 
         SparqlParser.primaryExpression_return primaryExpression376 =null;
 17934   
 
 17935  9208 
         SparqlParser.primaryExpression_return primaryExpression377 =null;
 17936   
 
 17937   
 
 17938  9208 
         Object char_literal371_tree=null;
 17939  9208 
         Object char_literal373_tree=null;
 17940  9208 
         Object char_literal375_tree=null;
 17941  9208 
         RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
 17942  9208 
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 17943  9208 
         RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
 17944  9208 
         RewriteRuleSubtreeStream stream_primaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule primaryExpression");
 17945   
         try {
 17946   
             // com\\googlecode\\sparkleg\\Sparql.g:558:5: ( '!' primaryExpression -> ^( UNARY '!' primaryExpression ) | '+' primaryExpression -> ^( UNARY '+' primaryExpression ) | '-' primaryExpression -> ^( UNARY '-' primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) )
 17947  9208 
             int alt122=4;
 17948  9208 
             switch ( input.LA(1) ) {
 17949   
             case NEGATION:
 17950   
                 {
 17951  152 
                 alt122=1;
 17952   
                 }
 17953  152 
                 break;
 17954   
             case PLUS:
 17955   
                 {
 17956  0 
                 alt122=2;
 17957   
                 }
 17958  0 
                 break;
 17959   
             case MINUS:
 17960  2 
                 {
 17961  10 
                 alt122=3;
 17962   
                 }
 17963  8 
                 break;
 17964  2 
             case ABS:
 17965  2 
             case AVG:
 17966   
             case BNODE:
 17967  2 
             case BOUND:
 17968   
             case CEIL:
 17969  2 
             case COALESCE:
 17970   
             case CONCAT:
 17971   
             case CONTAINS:
 17972   
             case COUNT:
 17973   
             case DATATYPE:
 17974   
             case DAY:
 17975   
             case DECIMAL:
 17976   
             case DECIMAL_NEGATIVE:
 17977   
             case DECIMAL_POSITIVE:
 17978  2 
             case DOUBLE:
 17979  2 
             case DOUBLE_NEGATIVE:
 17980   
             case DOUBLE_POSITIVE:
 17981  2 
             case ENCODE_FOR_URI:
 17982   
             case EXISTS:
 17983   
             case FALSE:
 17984   
             case FLOOR:
 17985   
             case GROUP_CONCAT:
 17986  2 
             case HOURS:
 17987  2 
             case IF:
 17988   
             case INTEGER:
 17989   
             case INTEGER_NEGATIVE:
 17990   
             case INTEGER_POSITIVE:
 17991  2 
             case IRI:
 17992   
             case IRI_REF:
 17993   
             case ISBLANK:
 17994   
             case ISIRI:
 17995  2 
             case ISLITERAL:
 17996   
             case ISNUMERIC:
 17997  2 
             case ISURI:
 17998   
             case LANG:
 17999   
             case LANGMATCHES:
 18000   
             case LCASE:
 18001   
             case MAX:
 18002   
             case MD5:
 18003  2 
             case MIN:
 18004   
             case MINUTES:
 18005   
             case MONTH:
 18006  2 
             case NOT:
 18007   
             case NOW:
 18008   
             case PNAME_LN:
 18009   
             case PNAME_NS:
 18010  2252 
             case RAND:
 18011  2252 
             case REGEX:
 18012   
             case REPLACE:
 18013  2252 
             case ROUND:
 18014   
             case SAMETERM:
 18015  2252 
             case SAMPLE:
 18016   
             case SECONDS:
 18017   
             case SHA1:
 18018   
             case SHA256:
 18019   
             case SHA384:
 18020   
             case SHA512:
 18021   
             case STR:
 18022   
             case STRAFTER:
 18023   
             case STRBEFORE:
 18024  2252 
             case STRDT:
 18025  2252 
             case STRENDS:
 18026   
             case STRING_LITERAL1:
 18027  2252 
             case STRING_LITERAL2:
 18028   
             case STRING_LITERAL_LONG1:
 18029   
             case STRING_LITERAL_LONG2:
 18030   
             case STRLANG:
 18031   
             case STRLEN:
 18032  2252 
             case STRSTARTS:
 18033  2252 
             case SUBSTR:
 18034   
             case SUM:
 18035   
             case TIMEZONE:
 18036   
             case TRUE:
 18037  2252 
             case TZ:
 18038   
             case UCASE:
 18039  2252 
             case URI:
 18040   
             case VAR1:
 18041   
             case VAR2:
 18042   
             case YEAR:
 18043   
             case 209:
 18044   
                 {
 18045  11296 
                 alt122=4;
 18046   
                 }
 18047  9044 
                 break;
 18048   
             default:
 18049  4 
                 NoViableAltException nvae =
 18050   
                     new NoViableAltException("", 122, 0, input);
 18051  2292 
 
 18052  4 
                 throw nvae;
 18053   
 
 18054  2292 
             }
 18055  2292 
 
 18056  9204 
             switch (alt122) {
 18057   
                 case 1 :
 18058  4 
                     // com\\googlecode\\sparkleg\\Sparql.g:558:7: '!' primaryExpression
 18059  4 
                     {
 18060  156 
                     char_literal371=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_unaryExpression5116);
 18061  156 
                     stream_NEGATION.add(char_literal371);
 18062   
 
 18063   
 
 18064  152 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression5118);
 18065  152 
                     primaryExpression372=primaryExpression();
 18066   
 
 18067  2448 
                     state._fsp--;
 18068  2296 
 
 18069  152 
                     stream_primaryExpression.add(primaryExpression372.getTree());
 18070   
 
 18071   
                     // AST REWRITE
 18072   
                     // elements: primaryExpression, NEGATION
 18073  2292 
                     // token labels:
 18074   
                     // rule labels: retval
 18075  2292 
                     // token list labels:
 18076   
                     // rule list labels:
 18077   
                     // wildcard labels:
 18078  152 
                     retval.tree = root_0;
 18079  152 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18080   
 
 18081  152 
                     root_0 = (Object)adaptor.nil();
 18082  2292 
                     // 558:29: -> ^( UNARY '!' primaryExpression )
 18083  2292 
                     {
 18084   
                         // com\\googlecode\\sparkleg\\Sparql.g:558:32: ^( UNARY '!' primaryExpression )
 18085   
                         {
 18086  2444 
                         Object root_1 = (Object)adaptor.nil();
 18087  152 
                         root_1 = (Object)adaptor.becomeRoot(
 18088  2292 
                         (Object)adaptor.create(UNARY, "UNARY")
 18089   
                         , root_1);
 18090  2292 
 
 18091  152 
                         adaptor.addChild(root_1,
 18092  2292 
                         stream_NEGATION.nextNode()
 18093   
                         );
 18094  2292 
 
 18095  152 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 18096  2292 
 
 18097  152 
                         adaptor.addChild(root_0, root_1);
 18098  2292 
                         }
 18099   
 
 18100  2292 
                     }
 18101   
 
 18102  2292 
 
 18103  152 
                     retval.tree = root_0;
 18104   
 
 18105   
                     }
 18106  152 
                     break;
 18107   
                 case 2 :
 18108  2292 
                     // com\\googlecode\\sparkleg\\Sparql.g:559:7: '+' primaryExpression
 18109  2292 
                     {
 18110  0 
                     char_literal373=(Token)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression5136);
 18111  0 
                     stream_PLUS.add(char_literal373);
 18112  48 
 
 18113   
 
 18114  48 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression5138);
 18115  0 
                     primaryExpression374=primaryExpression();
 18116   
 
 18117  0 
                     state._fsp--;
 18118   
 
 18119  0 
                     stream_primaryExpression.add(primaryExpression374.getTree());
 18120   
 
 18121   
                     // AST REWRITE
 18122   
                     // elements: primaryExpression, PLUS
 18123   
                     // token labels:
 18124   
                     // rule labels: retval
 18125   
                     // token list labels:
 18126   
                     // rule list labels:
 18127   
                     // wildcard labels:
 18128  0 
                     retval.tree = root_0;
 18129  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18130   
 
 18131  0 
                     root_0 = (Object)adaptor.nil();
 18132   
                     // 559:29: -> ^( UNARY '+' primaryExpression )
 18133   
                     {
 18134   
                         // com\\googlecode\\sparkleg\\Sparql.g:559:32: ^( UNARY '+' primaryExpression )
 18135   
                         {
 18136  0 
                         Object root_1 = (Object)adaptor.nil();
 18137  0 
                         root_1 = (Object)adaptor.becomeRoot(
 18138   
                         (Object)adaptor.create(UNARY, "UNARY")
 18139   
                         , root_1);
 18140   
 
 18141  0 
                         adaptor.addChild(root_1,
 18142   
                         stream_PLUS.nextNode()
 18143   
                         );
 18144   
 
 18145  0 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 18146   
 
 18147  0 
                         adaptor.addChild(root_0, root_1);
 18148   
                         }
 18149   
 
 18150   
                     }
 18151   
 
 18152   
 
 18153  0 
                     retval.tree = root_0;
 18154   
 
 18155   
                     }
 18156  0 
                     break;
 18157   
                 case 3 :
 18158   
                     // com\\googlecode\\sparkleg\\Sparql.g:560:7: '-' primaryExpression
 18159   
                     {
 18160  8 
                     char_literal375=(Token)match(input,MINUS,FOLLOW_MINUS_in_unaryExpression5156);
 18161  8 
                     stream_MINUS.add(char_literal375);
 18162   
 
 18163   
 
 18164  8 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression5158);
 18165  8 
                     primaryExpression376=primaryExpression();
 18166   
 
 18167  8 
                     state._fsp--;
 18168  374 
 
 18169  8 
                     stream_primaryExpression.add(primaryExpression376.getTree());
 18170  374 
 
 18171   
                     // AST REWRITE
 18172   
                     // elements: MINUS, primaryExpression
 18173   
                     // token labels:
 18174   
                     // rule labels: retval
 18175  176 
                     // token list labels:
 18176   
                     // rule list labels:
 18177  176 
                     // wildcard labels:
 18178  8 
                     retval.tree = root_0;
 18179  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18180   
 
 18181  8 
                     root_0 = (Object)adaptor.nil();
 18182   
                     // 560:29: -> ^( UNARY '-' primaryExpression )
 18183  208 
                     {
 18184   
                         // com\\googlecode\\sparkleg\\Sparql.g:560:32: ^( UNARY '-' primaryExpression )
 18185  208 
                         {
 18186  8 
                         Object root_1 = (Object)adaptor.nil();
 18187  8 
                         root_1 = (Object)adaptor.becomeRoot(
 18188   
                         (Object)adaptor.create(UNARY, "UNARY")
 18189   
                         , root_1);
 18190   
 
 18191  8 
                         adaptor.addChild(root_1,
 18192   
                         stream_MINUS.nextNode()
 18193   
                         );
 18194   
 
 18195  8 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 18196  186 
 
 18197  8 
                         adaptor.addChild(root_0, root_1);
 18198  186 
                         }
 18199   
 
 18200   
                     }
 18201   
 
 18202  12 
 
 18203  8 
                     retval.tree = root_0;
 18204  12 
 
 18205   
                     }
 18206  8 
                     break;
 18207   
                 case 4 :
 18208  1182 
                     // com\\googlecode\\sparkleg\\Sparql.g:561:7: primaryExpression
 18209   
                     {
 18210  10226 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression5176);
 18211  9044 
                     primaryExpression377=primaryExpression();
 18212   
 
 18213  9044 
                     state._fsp--;
 18214   
 
 18215  9044 
                     stream_primaryExpression.add(primaryExpression377.getTree());
 18216   
 
 18217   
                     // AST REWRITE
 18218   
                     // elements: primaryExpression
 18219  106 
                     // token labels:
 18220   
                     // rule labels: retval
 18221  106 
                     // token list labels:
 18222   
                     // rule list labels:
 18223   
                     // wildcard labels:
 18224  9044 
                     retval.tree = root_0;
 18225  9044 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18226   
 
 18227  9044 
                     root_0 = (Object)adaptor.nil();
 18228   
                     // 561:25: -> ^( UNARY primaryExpression )
 18229   
                     {
 18230  2292 
                         // com\\googlecode\\sparkleg\\Sparql.g:561:28: ^( UNARY primaryExpression )
 18231   
                         {
 18232  9044 
                         Object root_1 = (Object)adaptor.nil();
 18233  9044 
                         root_1 = (Object)adaptor.becomeRoot(
 18234  48 
                         (Object)adaptor.create(UNARY, "UNARY")
 18235   
                         , root_1);
 18236   
 
 18237  9092 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 18238  48 
 
 18239  9044 
                         adaptor.addChild(root_0, root_1);
 18240  48 
                         }
 18241   
 
 18242  48 
                     }
 18243   
 
 18244   
 
 18245  9092 
                     retval.tree = root_0;
 18246   
 
 18247   
                     }
 18248   
                     break;
 18249  374 
 
 18250   
             }
 18251  9204 
             retval.stop = input.LT(-1);
 18252  374 
 
 18253  374 
 
 18254  9204 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18255  9578 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18256   
 
 18257  374 
         }
 18258  4 
         catch (RecognitionException re) {
 18259  4 
             reportError(re);
 18260  378 
             recover(input,re);
 18261  4 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18262   
 
 18263   
         }
 18264  176 
 
 18265  0 
         finally {
 18266   
                 // do for sure before leaving
 18267  9384 
         }
 18268  9384 
         return retval;
 18269   
     }
 18270  176 
     // $ANTLR end "unaryExpression"
 18271   
 
 18272  176 
 
 18273  9204 
     public static class primaryExpression_return extends ParserRuleReturnScope {
 18274   
         Object tree;
 18275  176 
         public Object getTree() { return tree; }
 18276   
     };
 18277   
 
 18278   
 
 18279  208 
     // $ANTLR start "primaryExpression"
 18280   
     // com\\googlecode\\sparkleg\\Sparql.g:564:1: primaryExpression : ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate );
 18281   
     public final SparqlParser.primaryExpression_return primaryExpression() throws RecognitionException {
 18282  9412 
         SparqlParser.primaryExpression_return retval = new SparqlParser.primaryExpression_return();
 18283  9412 
         retval.start = input.LT(1);
 18284   
 
 18285  208 
 
 18286  9204 
         Object root_0 = null;
 18287  208 
 
 18288  9204 
         SparqlParser.brackettedExpression_return brackettedExpression378 =null;
 18289   
 
 18290  9412 
         SparqlParser.builtInCall_return builtInCall379 =null;
 18291   
 
 18292  9204 
         SparqlParser.iriRefOrFunction_return iriRefOrFunction380 =null;
 18293   
 
 18294  9390 
         SparqlParser.rdfLiteral_return rdfLiteral381 =null;
 18295   
 
 18296  9204 
         SparqlParser.numericLiteral_return numericLiteral382 =null;
 18297  186 
 
 18298  9390 
         SparqlParser.booleanLiteral_return booleanLiteral383 =null;
 18299   
 
 18300  9390 
         SparqlParser.var_return var384 =null;
 18301   
 
 18302  9390 
         SparqlParser.aggregate_return aggregate385 =null;
 18303   
 
 18304   
 
 18305  186 
 
 18306   
         try {
 18307   
             // com\\googlecode\\sparkleg\\Sparql.g:565:5: ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate )
 18308  9204 
             int alt123=8;
 18309  9216 
             switch ( input.LA(1) ) {
 18310   
             case 209:
 18311   
                 {
 18312  204 
                 alt123=1;
 18313  12 
                 }
 18314  192 
                 break;
 18315  12 
             case ABS:
 18316   
             case BNODE:
 18317  12 
             case BOUND:
 18318   
             case CEIL:
 18319   
             case COALESCE:
 18320  12 
             case CONCAT:
 18321   
             case CONTAINS:
 18322   
             case DATATYPE:
 18323   
             case DAY:
 18324  1182 
             case ENCODE_FOR_URI:
 18325   
             case EXISTS:
 18326   
             case FLOOR:
 18327  1182 
             case HOURS:
 18328  1182 
             case IF:
 18329   
             case IRI:
 18330  1182 
             case ISBLANK:
 18331   
             case ISIRI:
 18332  1182 
             case ISLITERAL:
 18333   
             case ISNUMERIC:
 18334   
             case ISURI:
 18335  1182 
             case LANG:
 18336   
             case LANGMATCHES:
 18337   
             case LCASE:
 18338   
             case MD5:
 18339  106 
             case MINUTES:
 18340   
             case MONTH:
 18341   
             case NOT:
 18342  106 
             case NOW:
 18343  106 
             case RAND:
 18344   
             case REGEX:
 18345  106 
             case REPLACE:
 18346   
             case ROUND:
 18347  106 
             case SAMETERM:
 18348   
             case SECONDS:
 18349   
             case SHA1:
 18350   
             case SHA256:
 18351   
             case SHA384:
 18352   
             case SHA512:
 18353  2292 
             case STR:
 18354   
             case STRAFTER:
 18355   
             case STRBEFORE:
 18356  2292 
             case STRDT:
 18357  2292 
             case STRENDS:
 18358   
             case STRLANG:
 18359   
             case STRLEN:
 18360   
             case STRSTARTS:
 18361   
             case SUBSTR:
 18362   
             case TIMEZONE:
 18363   
             case TZ:
 18364   
             case UCASE:
 18365   
             case URI:
 18366   
             case YEAR:
 18367   
                 {
 18368  1496 
                 alt123=2;
 18369  2292 
                 }
 18370  3788 
                 break;
 18371   
             case IRI_REF:
 18372   
             case PNAME_LN:
 18373   
             case PNAME_NS:
 18374   
                 {
 18375  704 
                 alt123=3;
 18376   
                 }
 18377  704 
                 break;
 18378   
             case STRING_LITERAL1:
 18379   
             case STRING_LITERAL2:
 18380   
             case STRING_LITERAL_LONG1:
 18381   
             case STRING_LITERAL_LONG2:
 18382   
                 {
 18383  832 
                 alt123=4;
 18384  544 
                 }
 18385  1376 
                 break;
 18386   
             case DECIMAL:
 18387   
             case DECIMAL_NEGATIVE:
 18388  544 
             case DECIMAL_POSITIVE:
 18389   
             case DOUBLE:
 18390  544 
             case DOUBLE_NEGATIVE:
 18391  544 
             case DOUBLE_POSITIVE:
 18392  544 
             case INTEGER:
 18393   
             case INTEGER_NEGATIVE:
 18394   
             case INTEGER_POSITIVE:
 18395  544 
                 {
 18396  1348 
                 alt123=5;
 18397  544 
                 }
 18398  1348 
                 break;
 18399  544 
             case FALSE:
 18400   
             case TRUE:
 18401   
                 {
 18402  48 
                 alt123=6;
 18403   
                 }
 18404  592 
                 break;
 18405  544 
             case VAR1:
 18406   
             case VAR2:
 18407   
                 {
 18408  5248 
                 alt123=7;
 18409  544 
                 }
 18410  4704 
                 break;
 18411  544 
             case AVG:
 18412   
             case COUNT:
 18413  544 
             case GROUP_CONCAT:
 18414   
             case MAX:
 18415  544 
             case MIN:
 18416  544 
             case SAMPLE:
 18417   
             case SUM:
 18418   
                 {
 18419  424 
                 alt123=8;
 18420   
                 }
 18421  424 
                 break;
 18422   
             default:
 18423  0 
                 NoViableAltException nvae =
 18424   
                     new NoViableAltException("", 123, 0, input);
 18425   
 
 18426  544 
                 throw nvae;
 18427  544 
 
 18428   
             }
 18429  544 
 
 18430  9204 
             switch (alt123) {
 18431   
                 case 1 :
 18432   
                     // com\\googlecode\\sparkleg\\Sparql.g:565:7: brackettedExpression
 18433   
                     {
 18434  736 
                     root_0 = (Object)adaptor.nil();
 18435  544 
 
 18436   
 
 18437  192 
                     pushFollow(FOLLOW_brackettedExpression_in_primaryExpression5201);
 18438  192 
                     brackettedExpression378=brackettedExpression();
 18439  544 
 
 18440  192 
                     state._fsp--;
 18441  544 
 
 18442  192 
                     adaptor.addChild(root_0, brackettedExpression378.getTree());
 18443   
 
 18444   
                     }
 18445  192 
                     break;
 18446   
                 case 2 :
 18447  544 
                     // com\\googlecode\\sparkleg\\Sparql.g:565:30: builtInCall
 18448   
                     {
 18449  1496 
                     root_0 = (Object)adaptor.nil();
 18450   
 
 18451  544 
 
 18452  1496 
                     pushFollow(FOLLOW_builtInCall_in_primaryExpression5205);
 18453  1496 
                     builtInCall379=builtInCall();
 18454  544 
 
 18455  2040 
                     state._fsp--;
 18456   
 
 18457  1496 
                     adaptor.addChild(root_0, builtInCall379.getTree());
 18458   
 
 18459   
                     }
 18460  1496 
                     break;
 18461   
                 case 3 :
 18462   
                     // com\\googlecode\\sparkleg\\Sparql.g:565:44: iriRefOrFunction
 18463   
                     {
 18464  704 
                     root_0 = (Object)adaptor.nil();
 18465   
 
 18466   
 
 18467  1248 
                     pushFollow(FOLLOW_iriRefOrFunction_in_primaryExpression5209);
 18468  1248 
                     iriRefOrFunction380=iriRefOrFunction();
 18469   
 
 18470  704 
                     state._fsp--;
 18471   
 
 18472  704 
                     adaptor.addChild(root_0, iriRefOrFunction380.getTree());
 18473  532 
 
 18474   
                     }
 18475  704 
                     break;
 18476   
                 case 4 :
 18477   
                     // com\\googlecode\\sparkleg\\Sparql.g:565:63: rdfLiteral
 18478   
                     {
 18479  832 
                     root_0 = (Object)adaptor.nil();
 18480   
 
 18481   
 
 18482  1364 
                     pushFollow(FOLLOW_rdfLiteral_in_primaryExpression5213);
 18483  1364 
                     rdfLiteral381=rdfLiteral();
 18484   
 
 18485  832 
                     state._fsp--;
 18486  532 
 
 18487  832 
                     adaptor.addChild(root_0, rdfLiteral381.getTree());
 18488  532 
 
 18489  532 
                     }
 18490  1364 
                     break;
 18491  532 
                 case 5 :
 18492  532 
                     // com\\googlecode\\sparkleg\\Sparql.g:565:76: numericLiteral
 18493  532 
                     {
 18494  1336 
                     root_0 = (Object)adaptor.nil();
 18495  532 
 
 18496  532 
 
 18497  1336 
                     pushFollow(FOLLOW_numericLiteral_in_primaryExpression5217);
 18498  1336 
                     numericLiteral382=numericLiteral();
 18499  532 
 
 18500  1336 
                     state._fsp--;
 18501  532 
 
 18502  1336 
                     adaptor.addChild(root_0, numericLiteral382.getTree());
 18503  532 
 
 18504  532 
                     }
 18505  1336 
                     break;
 18506  532 
                 case 6 :
 18507  532 
                     // com\\googlecode\\sparkleg\\Sparql.g:565:93: booleanLiteral
 18508  532 
                     {
 18509  580 
                     root_0 = (Object)adaptor.nil();
 18510  532 
 
 18511  532 
 
 18512  580 
                     pushFollow(FOLLOW_booleanLiteral_in_primaryExpression5221);
 18513  580 
                     booleanLiteral383=booleanLiteral();
 18514  532 
 
 18515  580 
                     state._fsp--;
 18516  532 
 
 18517  580 
                     adaptor.addChild(root_0, booleanLiteral383.getTree());
 18518  532 
 
 18519  532 
                     }
 18520  580 
                     break;
 18521  532 
                 case 7 :
 18522  532 
                     // com\\googlecode\\sparkleg\\Sparql.g:565:110: var
 18523  532 
                     {
 18524  5236 
                     root_0 = (Object)adaptor.nil();
 18525  532 
 
 18526  532 
 
 18527  5236 
                     pushFollow(FOLLOW_var_in_primaryExpression5225);
 18528  5236 
                     var384=var();
 18529  532 
 
 18530  5236 
                     state._fsp--;
 18531  532 
 
 18532  5236 
                     adaptor.addChild(root_0, var384.getTree());
 18533  532 
 
 18534  532 
                     }
 18535  5236 
                     break;
 18536  532 
                 case 8 :
 18537  532 
                     // com\\googlecode\\sparkleg\\Sparql.g:565:116: aggregate
 18538  532 
                     {
 18539  956 
                     root_0 = (Object)adaptor.nil();
 18540  532 
 
 18541  532 
 
 18542  956 
                     pushFollow(FOLLOW_aggregate_in_primaryExpression5229);
 18543  956 
                     aggregate385=aggregate();
 18544  532 
 
 18545  956 
                     state._fsp--;
 18546  532 
 
 18547  956 
                     adaptor.addChild(root_0, aggregate385.getTree());
 18548  532 
 
 18549  532 
                     }
 18550  532 
                     break;
 18551  532 
 
 18552  532 
             }
 18553  9736 
             retval.stop = input.LT(-1);
 18554  532 
 
 18555  532 
 
 18556  9736 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18557  9736 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18558  532 
 
 18559  532 
         }
 18560  532 
         catch (RecognitionException re) {
 18561  532 
             reportError(re);
 18562  532 
             recover(input,re);
 18563  532 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18564  532 
 
 18565  532 
         }
 18566  532 
 
 18567  532 
         finally {
 18568  532 
                 // do for sure before leaving
 18569  9736 
         }
 18570  9736 
         return retval;
 18571  532 
     }
 18572  532 
     // $ANTLR end "primaryExpression"
 18573  532 
 
 18574  532 
 
 18575  532 
     public static class brackettedExpression_return extends ParserRuleReturnScope {
 18576  532 
         Object tree;
 18577  532 
         public Object getTree() { return tree; }
 18578  532 
     };
 18579  532 
 
 18580  532 
 
 18581  532 
     // $ANTLR start "brackettedExpression"
 18582  532 
     // com\\googlecode\\sparkleg\\Sparql.g:568:1: brackettedExpression : '(' expression ')' -> ^( BRACKETTED_EXPRESSION expression ) ;
 18583  532 
     public final SparqlParser.brackettedExpression_return brackettedExpression() throws RecognitionException {
 18584  2672 
         SparqlParser.brackettedExpression_return retval = new SparqlParser.brackettedExpression_return();
 18585  2672 
         retval.start = input.LT(1);
 18586  532 
 
 18587  532 
 
 18588  2672 
         Object root_0 = null;
 18589  532 
 
 18590  2672 
         Token char_literal386=null;
 18591  2672 
         Token char_literal388=null;
 18592  2672 
         SparqlParser.expression_return expression387 =null;
 18593  532 
 
 18594  532 
 
 18595  2672 
         Object char_literal386_tree=null;
 18596  2672 
         Object char_literal388_tree=null;
 18597  2672 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 18598  2672 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 18599  2672 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18600  532 
         try {
 18601  532 
             // com\\googlecode\\sparkleg\\Sparql.g:569:5: ( '(' expression ')' -> ^( BRACKETTED_EXPRESSION expression ) )
 18602  532 
             // com\\googlecode\\sparkleg\\Sparql.g:569:7: '(' expression ')'
 18603  532 
             {
 18604  2672 
             char_literal386=(Token)match(input,209,FOLLOW_209_in_brackettedExpression5246);
 18605  2672 
             stream_209.add(char_literal386);
 18606  532 
 
 18607  532 
 
 18608  2672 
             pushFollow(FOLLOW_expression_in_brackettedExpression5248);
 18609  2672 
             expression387=expression();
 18610  532 
 
 18611  2672 
             state._fsp--;
 18612  532 
 
 18613  2672 
             stream_expression.add(expression387.getTree());
 18614  532 
 
 18615  2672 
             char_literal388=(Token)match(input,210,FOLLOW_210_in_brackettedExpression5250);
 18616  2672 
             stream_210.add(char_literal388);
 18617  532 
 
 18618  532 
 
 18619  532 
             // AST REWRITE
 18620  532 
             // elements: expression
 18621  532 
             // token labels:
 18622  532 
             // rule labels: retval
 18623  532 
             // token list labels:
 18624  532 
             // rule list labels:
 18625  532 
             // wildcard labels:
 18626  2672 
             retval.tree = root_0;
 18627  2672 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18628  532 
 
 18629  2672 
             root_0 = (Object)adaptor.nil();
 18630  532 
             // 569:26: -> ^( BRACKETTED_EXPRESSION expression )
 18631  532 
             {
 18632  532 
                 // com\\googlecode\\sparkleg\\Sparql.g:569:29: ^( BRACKETTED_EXPRESSION expression )
 18633  532 
                 {
 18634  2140 
                 Object root_1 = (Object)adaptor.nil();
 18635  2672 
                 root_1 = (Object)adaptor.becomeRoot(
 18636   
                 (Object)adaptor.create(BRACKETTED_EXPRESSION, "BRACKETTED_EXPRESSION")
 18637  532 
                 , root_1);
 18638   
 
 18639  2672 
                 adaptor.addChild(root_1, stream_expression.nextTree());
 18640   
 
 18641  2672 
                 adaptor.addChild(root_0, root_1);
 18642   
                 }
 18643  532 
 
 18644   
             }
 18645  532 
 
 18646   
 
 18647  2672 
             retval.tree = root_0;
 18648   
 
 18649  532 
             }
 18650   
 
 18651  2672 
             retval.stop = input.LT(-1);
 18652   
 
 18653  532 
 
 18654  2140 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18655  2672 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18656   
 
 18657  532 
         }
 18658  0 
         catch (RecognitionException re) {
 18659  532 
             reportError(re);
 18660  0 
             recover(input,re);
 18661  532 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18662   
 
 18663  532 
         }
 18664   
 
 18665  532 
         finally {
 18666   
                 // do for sure before leaving
 18667  2672 
         }
 18668  2140 
         return retval;
 18669  532 
     }
 18670   
     // $ANTLR end "brackettedExpression"
 18671  532 
 
 18672   
 
 18673  532 
     public static class builtInCall_return extends ParserRuleReturnScope {
 18674   
         Object tree;
 18675  532 
         public Object getTree() { return tree; }
 18676   
     };
 18677  532 
 
 18678   
 
 18679  532 
     // $ANTLR start "builtInCall"
 18680   
     // com\\googlecode\\sparkleg\\Sparql.g:572:1: builtInCall : ( STR '(' expression ')' -> ^( STR expression ) | LANG '(' expression ')' -> ^( LANG expression ) | LANGMATCHES '(' expression ',' expression ')' -> ^( LANGMATCHES ( expression )+ ) | DATATYPE '(' expression ')' -> ^( DATATYPE expression ) | BOUND '(' var ')' -> ^( BOUND var ) | IRI '(' expression ')' -> ^( IRI expression ) | URI '(' expression ')' -> ^( URI expression ) | BNODE ( '(' expression ')' ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS '(' expression ')' -> ^( ABS expression ) | CEIL '(' expression ')' -> ^( CEIL expression ) | FLOOR '(' expression ')' -> ^( FLOOR expression ) | ROUND '(' expression ')' -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | strReplaceExpression -> strReplaceExpression | STRLEN '(' expression ')' -> ^( STRLEN expression ) | UCASE '(' expression ')' -> ^( UCASE expression ) | LCASE '(' expression ')' -> ^( LCASE expression ) | ENCODE_FOR_URI '(' expression ')' -> ^( ENCODE_FOR_URI expression ) | CONTAINS '(' expression ',' expression ')' -> ^( CONTAINS expression expression ) | STRSTARTS '(' expression ',' expression ')' -> ^( STRSTARTS expression expression ) | STRENDS '(' expression ',' expression ')' -> ^( STRENDS expression expression ) | STRBEFORE '(' expression ',' expression ')' -> ^( STRBEFORE expression expression ) | STRAFTER '(' expression ',' expression ')' -> ^( STRAFTER expression expression ) | YEAR '(' expression ')' -> ^( YEAR expression ) | MONTH '(' expression ')' -> ^( MONTH expression ) | DAY '(' expression ')' -> ^( DAY expression ) | HOURS '(' expression ')' -> ^( HOURS expression ) | MINUTES '(' expression ')' -> ^( MINUTES expression ) | SECONDS '(' expression ')' -> ^( SECONDS expression ) | TIMEZONE '(' expression ')' -> ^( TIMEZONE expression ) | TZ '(' expression ')' -> ^( TZ expression ) | NOW nil -> NOW | MD5 '(' expression ')' -> ^( MD5 expression ) | SHA1 '(' expression ')' -> ^( SHA1 expression ) | SHA256 '(' expression ')' -> ^( SHA256 expression ) | SHA384 '(' expression ')' -> ^( SHA384 expression ) | SHA512 '(' expression ')' -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF '(' e1= expression ',' e2= expression ',' e3= expression ')' -> ^( IF $e1 $e2 $e3) | STRLANG '(' expression ',' expression ')' -> ^( STRLANG expression expression ) | STRDT '(' expression ',' expression ')' -> ^( STRDT expression expression ) | SAMETERM '(' expression ',' expression ')' -> ^( SAMETERM expression expression ) | ISIRI '(' expression ')' -> ^( ISIRI expression ) | ISURI '(' expression ')' -> ^( ISURI expression ) | ISBLANK '(' expression ')' -> ^( ISBLANK expression ) | ISLITERAL '(' expression ')' -> ^( ISLITERAL expression ) | ISNUMERIC '(' expression ')' -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction );
 18681  532 
     public final SparqlParser.builtInCall_return builtInCall() throws RecognitionException {
 18682  2128 
         SparqlParser.builtInCall_return retval = new SparqlParser.builtInCall_return();
 18683  2660 
         retval.start = input.LT(1);
 18684   
 
 18685  532 
 
 18686  2128 
         Object root_0 = null;
 18687  532 
 
 18688  2128 
         Token STR389=null;
 18689  2660 
         Token char_literal390=null;
 18690  2128 
         Token char_literal392=null;
 18691  2660 
         Token LANG393=null;
 18692  2128 
         Token char_literal394=null;
 18693  2660 
         Token char_literal396=null;
 18694  2128 
         Token LANGMATCHES397=null;
 18695  2660 
         Token char_literal398=null;
 18696  2128 
         Token char_literal400=null;
 18697  2660 
         Token char_literal402=null;
 18698  2128 
         Token DATATYPE403=null;
 18699  2660 
         Token char_literal404=null;
 18700  2128 
         Token char_literal406=null;
 18701  2660 
         Token BOUND407=null;
 18702  2128 
         Token char_literal408=null;
 18703  2660 
         Token char_literal410=null;
 18704  2128 
         Token IRI411=null;
 18705  2660 
         Token char_literal412=null;
 18706  2128 
         Token char_literal414=null;
 18707  2660 
         Token URI415=null;
 18708  2128 
         Token char_literal416=null;
 18709  2660 
         Token char_literal418=null;
 18710  2128 
         Token BNODE419=null;
 18711  2660 
         Token char_literal420=null;
 18712  2128 
         Token char_literal422=null;
 18713  2660 
         Token BNODE423=null;
 18714  2128 
         Token RAND425=null;
 18715  2660 
         Token ABS427=null;
 18716  2128 
         Token char_literal428=null;
 18717  2660 
         Token char_literal430=null;
 18718  2128 
         Token CEIL431=null;
 18719  2660 
         Token char_literal432=null;
 18720  2128 
         Token char_literal434=null;
 18721  2660 
         Token FLOOR435=null;
 18722  2128 
         Token char_literal436=null;
 18723  2660 
         Token char_literal438=null;
 18724  2128 
         Token ROUND439=null;
 18725  2660 
         Token char_literal440=null;
 18726  2128 
         Token char_literal442=null;
 18727  2660 
         Token CONCAT443=null;
 18728  2128 
         Token STRLEN447=null;
 18729  2660 
         Token char_literal448=null;
 18730  2128 
         Token char_literal450=null;
 18731  2660 
         Token UCASE451=null;
 18732  2128 
         Token char_literal452=null;
 18733  2660 
         Token char_literal454=null;
 18734  2128 
         Token LCASE455=null;
 18735  2660 
         Token char_literal456=null;
 18736  2128 
         Token char_literal458=null;
 18737  2660 
         Token ENCODE_FOR_URI459=null;
 18738  2128 
         Token char_literal460=null;
 18739  2660 
         Token char_literal462=null;
 18740  2128 
         Token CONTAINS463=null;
 18741  2660 
         Token char_literal464=null;
 18742  2128 
         Token char_literal466=null;
 18743  2660 
         Token char_literal468=null;
 18744  2128 
         Token STRSTARTS469=null;
 18745  2660 
         Token char_literal470=null;
 18746  2128 
         Token char_literal472=null;
 18747  2660 
         Token char_literal474=null;
 18748  2128 
         Token STRENDS475=null;
 18749  2660 
         Token char_literal476=null;
 18750  2128 
         Token char_literal478=null;
 18751  2660 
         Token char_literal480=null;
 18752  2128 
         Token STRBEFORE481=null;
 18753  2660 
         Token char_literal482=null;
 18754  2128 
         Token char_literal484=null;
 18755  2660 
         Token char_literal486=null;
 18756  2128 
         Token STRAFTER487=null;
 18757  2660 
         Token char_literal488=null;
 18758  2128 
         Token char_literal490=null;
 18759  2660 
         Token char_literal492=null;
 18760  2128 
         Token YEAR493=null;
 18761  2128 
         Token char_literal494=null;
 18762  2660 
         Token char_literal496=null;
 18763  2660 
         Token MONTH497=null;
 18764  2660 
         Token char_literal498=null;
 18765  2660 
         Token char_literal500=null;
 18766  2660 
         Token DAY501=null;
 18767  2660 
         Token char_literal502=null;
 18768  2660 
         Token char_literal504=null;
 18769  2660 
         Token HOURS505=null;
 18770  2660 
         Token char_literal506=null;
 18771  2660 
         Token char_literal508=null;
 18772  2660 
         Token MINUTES509=null;
 18773  2660 
         Token char_literal510=null;
 18774  2660 
         Token char_literal512=null;
 18775  2660 
         Token SECONDS513=null;
 18776  2660 
         Token char_literal514=null;
 18777  2660 
         Token char_literal516=null;
 18778  2660 
         Token TIMEZONE517=null;
 18779  2660 
         Token char_literal518=null;
 18780  2660 
         Token char_literal520=null;
 18781  2660 
         Token TZ521=null;
 18782  2660 
         Token char_literal522=null;
 18783  2660 
         Token char_literal524=null;
 18784  2660 
         Token NOW525=null;
 18785  2660 
         Token MD5527=null;
 18786  2660 
         Token char_literal528=null;
 18787  2660 
         Token char_literal530=null;
 18788  2660 
         Token SHA1531=null;
 18789  2660 
         Token char_literal532=null;
 18790  2660 
         Token char_literal534=null;
 18791  2660 
         Token SHA256535=null;
 18792  2660 
         Token char_literal536=null;
 18793  2660 
         Token char_literal538=null;
 18794  2660 
         Token SHA384539=null;
 18795  2660 
         Token char_literal540=null;
 18796  2660 
         Token char_literal542=null;
 18797  2660 
         Token SHA512543=null;
 18798  2660 
         Token char_literal544=null;
 18799  2660 
         Token char_literal546=null;
 18800  2660 
         Token COALESCE547=null;
 18801  2660 
         Token IF549=null;
 18802  2660 
         Token char_literal550=null;
 18803  2660 
         Token char_literal551=null;
 18804  2660 
         Token char_literal552=null;
 18805  2660 
         Token char_literal553=null;
 18806  2660 
         Token STRLANG554=null;
 18807  2660 
         Token char_literal555=null;
 18808  2660 
         Token char_literal557=null;
 18809  2660 
         Token char_literal559=null;
 18810  2660 
         Token STRDT560=null;
 18811  2660 
         Token char_literal561=null;
 18812  2660 
         Token char_literal563=null;
 18813  2660 
         Token char_literal565=null;
 18814  2660 
         Token SAMETERM566=null;
 18815  2660 
         Token char_literal567=null;
 18816  2660 
         Token char_literal569=null;
 18817  2660 
         Token char_literal571=null;
 18818  2660 
         Token ISIRI572=null;
 18819  2660 
         Token char_literal573=null;
 18820  2660 
         Token char_literal575=null;
 18821  2660 
         Token ISURI576=null;
 18822  2660 
         Token char_literal577=null;
 18823  2660 
         Token char_literal579=null;
 18824  2660 
         Token ISBLANK580=null;
 18825  2660 
         Token char_literal581=null;
 18826  2660 
         Token char_literal583=null;
 18827  2660 
         Token ISLITERAL584=null;
 18828  2660 
         Token char_literal585=null;
 18829  2660 
         Token char_literal587=null;
 18830  2660 
         Token ISNUMERIC588=null;
 18831  2660 
         Token char_literal589=null;
 18832  2660 
         Token char_literal591=null;
 18833  2660 
         SparqlParser.expression_return e1 =null;
 18834  532 
 
 18835  2660 
         SparqlParser.expression_return e2 =null;
 18836  532 
 
 18837  2660 
         SparqlParser.expression_return e3 =null;
 18838  532 
 
 18839  2660 
         SparqlParser.expression_return expression391 =null;
 18840  532 
 
 18841  2660 
         SparqlParser.expression_return expression395 =null;
 18842  532 
 
 18843  2660 
         SparqlParser.expression_return expression399 =null;
 18844  532 
 
 18845  2660 
         SparqlParser.expression_return expression401 =null;
 18846  532 
 
 18847  2660 
         SparqlParser.expression_return expression405 =null;
 18848  532 
 
 18849  2660 
         SparqlParser.var_return var409 =null;
 18850  532 
 
 18851  2660 
         SparqlParser.expression_return expression413 =null;
 18852  532 
 
 18853  2660 
         SparqlParser.expression_return expression417 =null;
 18854  532 
 
 18855  2660 
         SparqlParser.expression_return expression421 =null;
 18856  532 
 
 18857  2660 
         SparqlParser.nil_return nil424 =null;
 18858  532 
 
 18859  2660 
         SparqlParser.nil_return nil426 =null;
 18860  532 
 
 18861  2660 
         SparqlParser.expression_return expression429 =null;
 18862  532 
 
 18863  2660 
         SparqlParser.expression_return expression433 =null;
 18864  532 
 
 18865  2660 
         SparqlParser.expression_return expression437 =null;
 18866  532 
 
 18867  2660 
         SparqlParser.expression_return expression441 =null;
 18868  532 
 
 18869  2660 
         SparqlParser.expressionList_return expressionList444 =null;
 18870  532 
 
 18871  2660 
         SparqlParser.subStringExpression_return subStringExpression445 =null;
 18872  532 
 
 18873  2660 
         SparqlParser.strReplaceExpression_return strReplaceExpression446 =null;
 18874  532 
 
 18875  2660 
         SparqlParser.expression_return expression449 =null;
 18876  532 
 
 18877  2660 
         SparqlParser.expression_return expression453 =null;
 18878  532 
 
 18879  2660 
         SparqlParser.expression_return expression457 =null;
 18880  532 
 
 18881  2660 
         SparqlParser.expression_return expression461 =null;
 18882  532 
 
 18883  2660 
         SparqlParser.expression_return expression465 =null;
 18884  532 
 
 18885  2660 
         SparqlParser.expression_return expression467 =null;
 18886  532 
 
 18887  2660 
         SparqlParser.expression_return expression471 =null;
 18888  532 
 
 18889  2660 
         SparqlParser.expression_return expression473 =null;
 18890  532 
 
 18891  2660 
         SparqlParser.expression_return expression477 =null;
 18892  532 
 
 18893  2660 
         SparqlParser.expression_return expression479 =null;
 18894  532 
 
 18895  2660 
         SparqlParser.expression_return expression483 =null;
 18896  532 
 
 18897  2660 
         SparqlParser.expression_return expression485 =null;
 18898  532 
 
 18899  2660 
         SparqlParser.expression_return expression489 =null;
 18900  532 
 
 18901  2660 
         SparqlParser.expression_return expression491 =null;
 18902  532 
 
 18903  2660 
         SparqlParser.expression_return expression495 =null;
 18904  532 
 
 18905  2660 
         SparqlParser.expression_return expression499 =null;
 18906  532 
 
 18907  2660 
         SparqlParser.expression_return expression503 =null;
 18908  532 
 
 18909  2660 
         SparqlParser.expression_return expression507 =null;
 18910  532 
 
 18911  2660 
         SparqlParser.expression_return expression511 =null;
 18912  532 
 
 18913  2660 
         SparqlParser.expression_return expression515 =null;
 18914  532 
 
 18915  2660 
         SparqlParser.expression_return expression519 =null;
 18916  532 
 
 18917  2660 
         SparqlParser.expression_return expression523 =null;
 18918  532 
 
 18919  2660 
         SparqlParser.nil_return nil526 =null;
 18920  532 
 
 18921  2660 
         SparqlParser.expression_return expression529 =null;
 18922  532 
 
 18923  2660 
         SparqlParser.expression_return expression533 =null;
 18924  532 
 
 18925  2660 
         SparqlParser.expression_return expression537 =null;
 18926  532 
 
 18927  2660 
         SparqlParser.expression_return expression541 =null;
 18928  532 
 
 18929  2660 
         SparqlParser.expression_return expression545 =null;
 18930  532 
 
 18931  2660 
         SparqlParser.expressionList_return expressionList548 =null;
 18932  532 
 
 18933  2660 
         SparqlParser.expression_return expression556 =null;
 18934  532 
 
 18935  2660 
         SparqlParser.expression_return expression558 =null;
 18936  532 
 
 18937  2660 
         SparqlParser.expression_return expression562 =null;
 18938  532 
 
 18939  2660 
         SparqlParser.expression_return expression564 =null;
 18940  532 
 
 18941  2660 
         SparqlParser.expression_return expression568 =null;
 18942  532 
 
 18943  2660 
         SparqlParser.expression_return expression570 =null;
 18944  532 
 
 18945  2660 
         SparqlParser.expression_return expression574 =null;
 18946  532 
 
 18947  2660 
         SparqlParser.expression_return expression578 =null;
 18948  532 
 
 18949  2660 
         SparqlParser.expression_return expression582 =null;
 18950  532 
 
 18951  2660 
         SparqlParser.expression_return expression586 =null;
 18952  532 
 
 18953  2660 
         SparqlParser.expression_return expression590 =null;
 18954  532 
 
 18955  2660 
         SparqlParser.regexExpression_return regexExpression592 =null;
 18956  532 
 
 18957  2660 
         SparqlParser.existsFunction_return existsFunction593 =null;
 18958  532 
 
 18959  2660 
         SparqlParser.notExistsFunction_return notExistsFunction594 =null;
 18960  532 
 
 18961  532 
 
 18962  2660 
         Object STR389_tree=null;
 18963  2660 
         Object char_literal390_tree=null;
 18964  2660 
         Object char_literal392_tree=null;
 18965  2660 
         Object LANG393_tree=null;
 18966  2128 
         Object char_literal394_tree=null;
 18967  2128 
         Object char_literal396_tree=null;
 18968  2660 
         Object LANGMATCHES397_tree=null;
 18969  2660 
         Object char_literal398_tree=null;
 18970  2128 
         Object char_literal400_tree=null;
 18971  2128 
         Object char_literal402_tree=null;
 18972  2164 
         Object DATATYPE403_tree=null;
 18973  2128 
         Object char_literal404_tree=null;
 18974  2164 
         Object char_literal406_tree=null;
 18975  2128 
         Object BOUND407_tree=null;
 18976  2128 
         Object char_literal408_tree=null;
 18977  2168 
         Object char_literal410_tree=null;
 18978  2128 
         Object IRI411_tree=null;
 18979  2168 
         Object char_literal412_tree=null;
 18980  2128 
         Object char_literal414_tree=null;
 18981  2128 
         Object URI415_tree=null;
 18982  2158 
         Object char_literal416_tree=null;
 18983  2128 
         Object char_literal418_tree=null;
 18984  2158 
         Object BNODE419_tree=null;
 18985  2128 
         Object char_literal420_tree=null;
 18986  2128 
         Object char_literal422_tree=null;
 18987  2228 
         Object BNODE423_tree=null;
 18988  2128 
         Object RAND425_tree=null;
 18989  2228 
         Object ABS427_tree=null;
 18990  2128 
         Object char_literal428_tree=null;
 18991  2128 
         Object char_literal430_tree=null;
 18992  2158 
         Object CEIL431_tree=null;
 18993  2128 
         Object char_literal432_tree=null;
 18994  2158 
         Object char_literal434_tree=null;
 18995  2128 
         Object FLOOR435_tree=null;
 18996  2128 
         Object char_literal436_tree=null;
 18997  2130 
         Object char_literal438_tree=null;
 18998  2128 
         Object ROUND439_tree=null;
 18999  2130 
         Object char_literal440_tree=null;
 19000  2128 
         Object char_literal442_tree=null;
 19001  2128 
         Object CONCAT443_tree=null;
 19002  2130 
         Object STRLEN447_tree=null;
 19003  2128 
         Object char_literal448_tree=null;
 19004  2130 
         Object char_literal450_tree=null;
 19005  2128 
         Object UCASE451_tree=null;
 19006  2128 
         Object char_literal452_tree=null;
 19007  2136 
         Object char_literal454_tree=null;
 19008  2128 
         Object LCASE455_tree=null;
 19009  2128 
         Object char_literal456_tree=null;
 19010  2136 
         Object char_literal458_tree=null;
 19011  2128 
         Object ENCODE_FOR_URI459_tree=null;
 19012  2128 
         Object char_literal460_tree=null;
 19013  2132 
         Object char_literal462_tree=null;
 19014  2128 
         Object CONTAINS463_tree=null;
 19015  2132 
         Object char_literal464_tree=null;
 19016  2128 
         Object char_literal466_tree=null;
 19017  2128 
         Object char_literal468_tree=null;
 19018  2128 
         Object STRSTARTS469_tree=null;
 19019  2128 
         Object char_literal470_tree=null;
 19020  2128 
         Object char_literal472_tree=null;
 19021  2128 
         Object char_literal474_tree=null;
 19022  2128 
         Object STRENDS475_tree=null;
 19023  2128 
         Object char_literal476_tree=null;
 19024  2128 
         Object char_literal478_tree=null;
 19025  2128 
         Object char_literal480_tree=null;
 19026  2128 
         Object STRBEFORE481_tree=null;
 19027  2128 
         Object char_literal482_tree=null;
 19028  2128 
         Object char_literal484_tree=null;
 19029  2128 
         Object char_literal486_tree=null;
 19030  2128 
         Object STRAFTER487_tree=null;
 19031  2128 
         Object char_literal488_tree=null;
 19032  2128 
         Object char_literal490_tree=null;
 19033  2128 
         Object char_literal492_tree=null;
 19034  2128 
         Object YEAR493_tree=null;
 19035  2128 
         Object char_literal494_tree=null;
 19036  2128 
         Object char_literal496_tree=null;
 19037  2128 
         Object MONTH497_tree=null;
 19038  2128 
         Object char_literal498_tree=null;
 19039  2128 
         Object char_literal500_tree=null;
 19040  2128 
         Object DAY501_tree=null;
 19041  2128 
         Object char_literal502_tree=null;
 19042  2128 
         Object char_literal504_tree=null;
 19043  2128 
         Object HOURS505_tree=null;
 19044  2128 
         Object char_literal506_tree=null;
 19045  2128 
         Object char_literal508_tree=null;
 19046  2128 
         Object MINUTES509_tree=null;
 19047  2128 
         Object char_literal510_tree=null;
 19048  2128 
         Object char_literal512_tree=null;
 19049  2128 
         Object SECONDS513_tree=null;
 19050  2128 
         Object char_literal514_tree=null;
 19051  2128 
         Object char_literal516_tree=null;
 19052  2128 
         Object TIMEZONE517_tree=null;
 19053  2128 
         Object char_literal518_tree=null;
 19054  2128 
         Object char_literal520_tree=null;
 19055  2128 
         Object TZ521_tree=null;
 19056  2128 
         Object char_literal522_tree=null;
 19057  2128 
         Object char_literal524_tree=null;
 19058  2128 
         Object NOW525_tree=null;
 19059  2128 
         Object MD5527_tree=null;
 19060  2128 
         Object char_literal528_tree=null;
 19061  2128 
         Object char_literal530_tree=null;
 19062  2128 
         Object SHA1531_tree=null;
 19063  2128 
         Object char_literal532_tree=null;
 19064  2128 
         Object char_literal534_tree=null;
 19065  2128 
         Object SHA256535_tree=null;
 19066  2128 
         Object char_literal536_tree=null;
 19067  2128 
         Object char_literal538_tree=null;
 19068  2128 
         Object SHA384539_tree=null;
 19069  2128 
         Object char_literal540_tree=null;
 19070  2128 
         Object char_literal542_tree=null;
 19071  2128 
         Object SHA512543_tree=null;
 19072  2128 
         Object char_literal544_tree=null;
 19073  2128 
         Object char_literal546_tree=null;
 19074  2128 
         Object COALESCE547_tree=null;
 19075  2128 
         Object IF549_tree=null;
 19076  2128 
         Object char_literal550_tree=null;
 19077  2128 
         Object char_literal551_tree=null;
 19078  2128 
         Object char_literal552_tree=null;
 19079  2128 
         Object char_literal553_tree=null;
 19080  2128 
         Object STRLANG554_tree=null;
 19081  2128 
         Object char_literal555_tree=null;
 19082  2128 
         Object char_literal557_tree=null;
 19083  2128 
         Object char_literal559_tree=null;
 19084  2128 
         Object STRDT560_tree=null;
 19085  2128 
         Object char_literal561_tree=null;
 19086  2128 
         Object char_literal563_tree=null;
 19087  2128 
         Object char_literal565_tree=null;
 19088  2128 
         Object SAMETERM566_tree=null;
 19089  2128 
         Object char_literal567_tree=null;
 19090  2128 
         Object char_literal569_tree=null;
 19091  2128 
         Object char_literal571_tree=null;
 19092  2128 
         Object ISIRI572_tree=null;
 19093  2128 
         Object char_literal573_tree=null;
 19094  2128 
         Object char_literal575_tree=null;
 19095  2128 
         Object ISURI576_tree=null;
 19096  2128 
         Object char_literal577_tree=null;
 19097  2128 
         Object char_literal579_tree=null;
 19098  2128 
         Object ISBLANK580_tree=null;
 19099  2128 
         Object char_literal581_tree=null;
 19100  2132 
         Object char_literal583_tree=null;
 19101  2128 
         Object ISLITERAL584_tree=null;
 19102  2132 
         Object char_literal585_tree=null;
 19103  2128 
         Object char_literal587_tree=null;
 19104  2128 
         Object ISNUMERIC588_tree=null;
 19105  2128 
         Object char_literal589_tree=null;
 19106  2128 
         Object char_literal591_tree=null;
 19107  2128 
         RewriteRuleTokenStream stream_SHA256=new RewriteRuleTokenStream(adaptor,"token SHA256");
 19108  2128 
         RewriteRuleTokenStream stream_YEAR=new RewriteRuleTokenStream(adaptor,"token YEAR");
 19109  2128 
         RewriteRuleTokenStream stream_TIMEZONE=new RewriteRuleTokenStream(adaptor,"token TIMEZONE");
 19110  2128 
         RewriteRuleTokenStream stream_CONTAINS=new RewriteRuleTokenStream(adaptor,"token CONTAINS");
 19111  2128 
         RewriteRuleTokenStream stream_STRENDS=new RewriteRuleTokenStream(adaptor,"token STRENDS");
 19112  2136 
         RewriteRuleTokenStream stream_LCASE=new RewriteRuleTokenStream(adaptor,"token LCASE");
 19113  2128 
         RewriteRuleTokenStream stream_BNODE=new RewriteRuleTokenStream(adaptor,"token BNODE");
 19114  2128 
         RewriteRuleTokenStream stream_SHA512=new RewriteRuleTokenStream(adaptor,"token SHA512");
 19115  2128 
         RewriteRuleTokenStream stream_SECONDS=new RewriteRuleTokenStream(adaptor,"token SECONDS");
 19116  2128 
         RewriteRuleTokenStream stream_NOW=new RewriteRuleTokenStream(adaptor,"token NOW");
 19117  2128 
         RewriteRuleTokenStream stream_DAY=new RewriteRuleTokenStream(adaptor,"token DAY");
 19118  2128 
         RewriteRuleTokenStream stream_STRAFTER=new RewriteRuleTokenStream(adaptor,"token STRAFTER");
 19119  2128 
         RewriteRuleTokenStream stream_STRLEN=new RewriteRuleTokenStream(adaptor,"token STRLEN");
 19120  2128 
         RewriteRuleTokenStream stream_MONTH=new RewriteRuleTokenStream(adaptor,"token MONTH");
 19121  2128 
         RewriteRuleTokenStream stream_ENCODE_FOR_URI=new RewriteRuleTokenStream(adaptor,"token ENCODE_FOR_URI");
 19122  2136 
         RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
 19123  2128 
         RewriteRuleTokenStream stream_ISURI=new RewriteRuleTokenStream(adaptor,"token ISURI");
 19124  2128 
         RewriteRuleTokenStream stream_STR=new RewriteRuleTokenStream(adaptor,"token STR");
 19125  2130 
         RewriteRuleTokenStream stream_STRDT=new RewriteRuleTokenStream(adaptor,"token STRDT");
 19126  2128 
         RewriteRuleTokenStream stream_ISLITERAL=new RewriteRuleTokenStream(adaptor,"token ISLITERAL");
 19127  2130 
         RewriteRuleTokenStream stream_SAMETERM=new RewriteRuleTokenStream(adaptor,"token SAMETERM");
 19128  2128 
         RewriteRuleTokenStream stream_MD5=new RewriteRuleTokenStream(adaptor,"token MD5");
 19129  2128 
         RewriteRuleTokenStream stream_RAND=new RewriteRuleTokenStream(adaptor,"token RAND");
 19130  2130 
         RewriteRuleTokenStream stream_IRI=new RewriteRuleTokenStream(adaptor,"token IRI");
 19131  2128 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 19132  2130 
         RewriteRuleTokenStream stream_LANGMATCHES=new RewriteRuleTokenStream(adaptor,"token LANGMATCHES");
 19133  2128 
         RewriteRuleTokenStream stream_TZ=new RewriteRuleTokenStream(adaptor,"token TZ");
 19134  2128 
         RewriteRuleTokenStream stream_STRLANG=new RewriteRuleTokenStream(adaptor,"token STRLANG");
 19135  2130 
         RewriteRuleTokenStream stream_BOUND=new RewriteRuleTokenStream(adaptor,"token BOUND");
 19136  2128 
         RewriteRuleTokenStream stream_ISIRI=new RewriteRuleTokenStream(adaptor,"token ISIRI");
 19137  2130 
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 19138  2128 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 19139  2128 
         RewriteRuleTokenStream stream_COALESCE=new RewriteRuleTokenStream(adaptor,"token COALESCE");
 19140  2130 
         RewriteRuleTokenStream stream_ISNUMERIC=new RewriteRuleTokenStream(adaptor,"token ISNUMERIC");
 19141  2128 
         RewriteRuleTokenStream stream_CONCAT=new RewriteRuleTokenStream(adaptor,"token CONCAT");
 19142  2130 
         RewriteRuleTokenStream stream_STRSTARTS=new RewriteRuleTokenStream(adaptor,"token STRSTARTS");
 19143  2128 
         RewriteRuleTokenStream stream_STRBEFORE=new RewriteRuleTokenStream(adaptor,"token STRBEFORE");
 19144  2128 
         RewriteRuleTokenStream stream_SHA1=new RewriteRuleTokenStream(adaptor,"token SHA1");
 19145  2130 
         RewriteRuleTokenStream stream_FLOOR=new RewriteRuleTokenStream(adaptor,"token FLOOR");
 19146  2128 
         RewriteRuleTokenStream stream_ISBLANK=new RewriteRuleTokenStream(adaptor,"token ISBLANK");
 19147  2130 
         RewriteRuleTokenStream stream_UCASE=new RewriteRuleTokenStream(adaptor,"token UCASE");
 19148  2128 
         RewriteRuleTokenStream stream_URI=new RewriteRuleTokenStream(adaptor,"token URI");
 19149  2128 
         RewriteRuleTokenStream stream_ABS=new RewriteRuleTokenStream(adaptor,"token ABS");
 19150  2138 
         RewriteRuleTokenStream stream_MINUTES=new RewriteRuleTokenStream(adaptor,"token MINUTES");
 19151  2128 
         RewriteRuleTokenStream stream_ROUND=new RewriteRuleTokenStream(adaptor,"token ROUND");
 19152  2138 
         RewriteRuleTokenStream stream_CEIL=new RewriteRuleTokenStream(adaptor,"token CEIL");
 19153  2128 
         RewriteRuleTokenStream stream_DATATYPE=new RewriteRuleTokenStream(adaptor,"token DATATYPE");
 19154  2128 
         RewriteRuleTokenStream stream_SHA384=new RewriteRuleTokenStream(adaptor,"token SHA384");
 19155  2132 
         RewriteRuleTokenStream stream_HOURS=new RewriteRuleTokenStream(adaptor,"token HOURS");
 19156  2128 
         RewriteRuleTokenStream stream_LANG=new RewriteRuleTokenStream(adaptor,"token LANG");
 19157  2132 
         RewriteRuleSubtreeStream stream_existsFunction=new RewriteRuleSubtreeStream(adaptor,"rule existsFunction");
 19158  2128 
         RewriteRuleSubtreeStream stream_subStringExpression=new RewriteRuleSubtreeStream(adaptor,"rule subStringExpression");
 19159  2128 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 19160  2134 
         RewriteRuleSubtreeStream stream_strReplaceExpression=new RewriteRuleSubtreeStream(adaptor,"rule strReplaceExpression");
 19161  2128 
         RewriteRuleSubtreeStream stream_notExistsFunction=new RewriteRuleSubtreeStream(adaptor,"rule notExistsFunction");
 19162  2134 
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 19163  2128 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 19164  2128 
         RewriteRuleSubtreeStream stream_regexExpression=new RewriteRuleSubtreeStream(adaptor,"rule regexExpression");
 19165  2130 
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 19166   
         try {
 19167  2 
             // com\\googlecode\\sparkleg\\Sparql.g:573:5: ( STR '(' expression ')' -> ^( STR expression ) | LANG '(' expression ')' -> ^( LANG expression ) | LANGMATCHES '(' expression ',' expression ')' -> ^( LANGMATCHES ( expression )+ ) | DATATYPE '(' expression ')' -> ^( DATATYPE expression ) | BOUND '(' var ')' -> ^( BOUND var ) | IRI '(' expression ')' -> ^( IRI expression ) | URI '(' expression ')' -> ^( URI expression ) | BNODE ( '(' expression ')' ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS '(' expression ')' -> ^( ABS expression ) | CEIL '(' expression ')' -> ^( CEIL expression ) | FLOOR '(' expression ')' -> ^( FLOOR expression ) | ROUND '(' expression ')' -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | strReplaceExpression -> strReplaceExpression | STRLEN '(' expression ')' -> ^( STRLEN expression ) | UCASE '(' expression ')' -> ^( UCASE expression ) | LCASE '(' expression ')' -> ^( LCASE expression ) | ENCODE_FOR_URI '(' expression ')' -> ^( ENCODE_FOR_URI expression ) | CONTAINS '(' expression ',' expression ')' -> ^( CONTAINS expression expression ) | STRSTARTS '(' expression ',' expression ')' -> ^( STRSTARTS expression expression ) | STRENDS '(' expression ',' expression ')' -> ^( STRENDS expression expression ) | STRBEFORE '(' expression ',' expression ')' -> ^( STRBEFORE expression expression ) | STRAFTER '(' expression ',' expression ')' -> ^( STRAFTER expression expression ) | YEAR '(' expression ')' -> ^( YEAR expression ) | MONTH '(' expression ')' -> ^( MONTH expression ) | DAY '(' expression ')' -> ^( DAY expression ) | HOURS '(' expression ')' -> ^( HOURS expression ) | MINUTES '(' expression ')' -> ^( MINUTES expression ) | SECONDS '(' expression ')' -> ^( SECONDS expression ) | TIMEZONE '(' expression ')' -> ^( TIMEZONE expression ) | TZ '(' expression ')' -> ^( TZ expression ) | NOW nil -> NOW | MD5 '(' expression ')' -> ^( MD5 expression ) | SHA1 '(' expression ')' -> ^( SHA1 expression ) | SHA256 '(' expression ')' -> ^( SHA256 expression ) | SHA384 '(' expression ')' -> ^( SHA384 expression ) | SHA512 '(' expression ')' -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF '(' e1= expression ',' e2= expression ',' e3= expression ')' -> ^( IF $e1 $e2 $e3) | STRLANG '(' expression ',' expression ')' -> ^( STRLANG expression expression ) | STRDT '(' expression ',' expression ')' -> ^( STRDT expression expression ) | SAMETERM '(' expression ',' expression ')' -> ^( SAMETERM expression expression ) | ISIRI '(' expression ')' -> ^( ISIRI expression ) | ISURI '(' expression ')' -> ^( ISURI expression ) | ISBLANK '(' expression ')' -> ^( ISBLANK expression ) | ISLITERAL '(' expression ')' -> ^( ISLITERAL expression ) | ISNUMERIC '(' expression ')' -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction )
 19168  2128 
             int alt124=53;
 19169  2128 
             switch ( input.LA(1) ) {
 19170  2 
             case STR:
 19171   
                 {
 19172  146 
                 alt124=1;
 19173   
                 }
 19174  144 
                 break;
 19175  2 
             case LANG:
 19176   
                 {
 19177  162 
                 alt124=2;
 19178   
                 }
 19179  160 
                 break;
 19180  2 
             case LANGMATCHES:
 19181   
                 {
 19182  122 
                 alt124=3;
 19183   
                 }
 19184  120 
                 break;
 19185  2 
             case DATATYPE:
 19186   
                 {
 19187  402 
                 alt124=4;
 19188   
                 }
 19189  400 
                 break;
 19190  2 
             case BOUND:
 19191   
                 {
 19192  122 
                 alt124=5;
 19193   
                 }
 19194  120 
                 break;
 19195  2 
             case IRI:
 19196   
                 {
 19197  10 
                 alt124=6;
 19198   
                 }
 19199  8 
                 break;
 19200  2 
             case URI:
 19201   
                 {
 19202  10 
                 alt124=7;
 19203   
                 }
 19204  8 
                 break;
 19205  2 
             case BNODE:
 19206   
                 {
 19207  34 
                 switch ( input.LA(2) ) {
 19208   
                 case 209:
 19209   
                     {
 19210  34 
                     switch ( input.LA(3) ) {
 19211   
                     case 210:
 19212  2 
                         {
 19213  16 
                         alt124=9;
 19214   
                         }
 19215  18 
                         break;
 19216   
                     case ABS:
 19217  2 
                     case AVG:
 19218   
                     case BNODE:
 19219   
                     case BOUND:
 19220  2 
                     case CEIL:
 19221   
                     case COALESCE:
 19222  2 
                     case CONCAT:
 19223   
                     case CONTAINS:
 19224   
                     case COUNT:
 19225  2 
                     case DATATYPE:
 19226   
                     case DAY:
 19227  2 
                     case DECIMAL:
 19228   
                     case DECIMAL_NEGATIVE:
 19229   
                     case DECIMAL_POSITIVE:
 19230  2 
                     case DOUBLE:
 19231   
                     case DOUBLE_NEGATIVE:
 19232  2 
                     case DOUBLE_POSITIVE:
 19233   
                     case ENCODE_FOR_URI:
 19234   
                     case EXISTS:
 19235  2 
                     case FALSE:
 19236   
                     case FLOOR:
 19237  2 
                     case GROUP_CONCAT:
 19238   
                     case HOURS:
 19239   
                     case IF:
 19240  2 
                     case INTEGER:
 19241   
                     case INTEGER_NEGATIVE:
 19242  2 
                     case INTEGER_POSITIVE:
 19243   
                     case IRI:
 19244   
                     case IRI_REF:
 19245  2 
                     case ISBLANK:
 19246   
                     case ISIRI:
 19247  2 
                     case ISLITERAL:
 19248   
                     case ISNUMERIC:
 19249   
                     case ISURI:
 19250  2 
                     case LANG:
 19251   
                     case LANGMATCHES:
 19252  2 
                     case LCASE:
 19253   
                     case MAX:
 19254   
                     case MD5:
 19255  4 
                     case MIN:
 19256   
                     case MINUS:
 19257  4 
                     case MINUTES:
 19258   
                     case MONTH:
 19259   
                     case NEGATION:
 19260  4 
                     case NOT:
 19261   
                     case NOW:
 19262  4 
                     case PLUS:
 19263   
                     case PNAME_LN:
 19264   
                     case PNAME_NS:
 19265  4 
                     case RAND:
 19266   
                     case REGEX:
 19267  4 
                     case REPLACE:
 19268   
                     case ROUND:
 19269   
                     case SAMETERM:
 19270  4 
                     case SAMPLE:
 19271   
                     case SECONDS:
 19272  4 
                     case SHA1:
 19273   
                     case SHA256:
 19274   
                     case SHA384:
 19275  4 
                     case SHA512:
 19276   
                     case STR:
 19277  4 
                     case STRAFTER:
 19278   
                     case STRBEFORE:
 19279   
                     case STRDT:
 19280  12 
                     case STRENDS:
 19281   
                     case STRING_LITERAL1:
 19282  12 
                     case STRING_LITERAL2:
 19283   
                     case STRING_LITERAL_LONG1:
 19284   
                     case STRING_LITERAL_LONG2:
 19285  6 
                     case STRLANG:
 19286   
                     case STRLEN:
 19287  6 
                     case STRSTARTS:
 19288   
                     case SUBSTR:
 19289   
                     case SUM:
 19290  6 
                     case TIMEZONE:
 19291   
                     case TRUE:
 19292  6 
                     case TZ:
 19293   
                     case UCASE:
 19294   
                     case URI:
 19295  6 
                     case VAR1:
 19296   
                     case VAR2:
 19297  6 
                     case YEAR:
 19298   
                     case 209:
 19299   
                         {
 19300  46 
                         alt124=8;
 19301   
                         }
 19302  46 
                         break;
 19303   
                     default:
 19304  0 
                         NoViableAltException nvae =
 19305  8 
                             new NoViableAltException("", 124, 53, input);
 19306   
 
 19307  8 
                         throw nvae;
 19308   
 
 19309   
                     }
 19310  2 
 
 19311   
                     }
 19312  34 
                     break;
 19313   
                 default:
 19314  0 
                     NoViableAltException nvae =
 19315  8 
                         new NoViableAltException("", 124, 8, input);
 19316   
 
 19317  8 
                     throw nvae;
 19318   
 
 19319   
                 }
 19320  8 
 
 19321   
                 }
 19322  40 
                 break;
 19323   
             case RAND:
 19324   
                 {
 19325  12 
                 alt124=10;
 19326   
                 }
 19327  12 
                 break;
 19328   
             case ABS:
 19329   
                 {
 19330  50 
                 alt124=11;
 19331   
                 }
 19332  50 
                 break;
 19333   
             case CEIL:
 19334   
                 {
 19335  28 
                 alt124=12;
 19336   
                 }
 19337  28 
                 break;
 19338   
             case FLOOR:
 19339   
                 {
 19340  54 
                 alt124=13;
 19341   
                 }
 19342  54 
                 break;
 19343   
             case ROUND:
 19344   
                 {
 19345  8 
                 alt124=14;
 19346   
                 }
 19347  8 
                 break;
 19348   
             case CONCAT:
 19349   
                 {
 19350  40 
                 alt124=15;
 19351  532 
                 }
 19352  40 
                 break;
 19353   
             case SUBSTR:
 19354   
                 {
 19355  52 
                 alt124=16;
 19356  36 
                 }
 19357  16 
                 break;
 19358   
             case REPLACE:
 19359  36 
                 {
 19360  60 
                 alt124=17;
 19361   
                 }
 19362  24 
                 break;
 19363  36 
             case STRLEN:
 19364  36 
                 {
 19365  8 
                 alt124=18;
 19366  36 
                 }
 19367  8 
                 break;
 19368  36 
             case UCASE:
 19369   
                 {
 19370  44 
                 alt124=19;
 19371  36 
                 }
 19372  8 
                 break;
 19373   
             case LCASE:
 19374   
                 {
 19375  8 
                 alt124=20;
 19376   
                 }
 19377  8 
                 break;
 19378   
             case ENCODE_FOR_URI:
 19379   
                 {
 19380  8 
                 alt124=21;
 19381  36 
                 }
 19382  44 
                 break;
 19383   
             case CONTAINS:
 19384  36 
                 {
 19385  8 
                 alt124=22;
 19386   
                 }
 19387  8 
                 break;
 19388   
             case STRSTARTS:
 19389  36 
                 {
 19390  44 
                 alt124=23;
 19391   
                 }
 19392  8 
                 break;
 19393   
             case STRENDS:
 19394  36 
                 {
 19395  8 
                 alt124=24;
 19396  36 
                 }
 19397  8 
                 break;
 19398   
             case STRBEFORE:
 19399   
                 {
 19400  8 
                 alt124=25;
 19401   
                 }
 19402  44 
                 break;
 19403   
             case STRAFTER:
 19404   
                 {
 19405  44 
                 alt124=26;
 19406   
                 }
 19407  8 
                 break;
 19408   
             case YEAR:
 19409  40 
                 {
 19410  48 
                 alt124=27;
 19411   
                 }
 19412  8 
                 break;
 19413  40 
             case MONTH:
 19414  40 
                 {
 19415  8 
                 alt124=28;
 19416   
                 }
 19417  48 
                 break;
 19418  40 
             case DAY:
 19419   
                 {
 19420  48 
                 alt124=29;
 19421   
                 }
 19422  48 
                 break;
 19423   
             case HOURS:
 19424  40 
                 {
 19425  48 
                 alt124=30;
 19426   
                 }
 19427  8 
                 break;
 19428   
             case MINUTES:
 19429   
                 {
 19430  8 
                 alt124=31;
 19431   
                 }
 19432  8 
                 break;
 19433   
             case SECONDS:
 19434   
                 {
 19435  48 
                 alt124=32;
 19436  40 
                 }
 19437  8 
                 break;
 19438  40 
             case TIMEZONE:
 19439   
                 {
 19440  8 
                 alt124=33;
 19441   
                 }
 19442  8 
                 break;
 19443  40 
             case TZ:
 19444  40 
                 {
 19445  8 
                 alt124=34;
 19446   
                 }
 19447  8 
                 break;
 19448  40 
             case NOW:
 19449   
                 {
 19450  48 
                 alt124=35;
 19451   
                 }
 19452  8 
                 break;
 19453   
             case MD5:
 19454   
                 {
 19455  16 
                 alt124=36;
 19456  40 
                 }
 19457  16 
                 break;
 19458   
             case SHA1:
 19459  40 
                 {
 19460  16 
                 alt124=37;
 19461   
                 }
 19462  16 
                 break;
 19463  30 
             case SHA256:
 19464  30 
                 {
 19465  16 
                 alt124=38;
 19466   
                 }
 19467  46 
                 break;
 19468  30 
             case SHA384:
 19469   
                 {
 19470  16 
                 alt124=39;
 19471  30 
                 }
 19472  46 
                 break;
 19473   
             case SHA512:
 19474  30 
                 {
 19475  16 
                 alt124=40;
 19476  30 
                 }
 19477  16 
                 break;
 19478  30 
             case COALESCE:
 19479  30 
                 {
 19480  48 
                 alt124=41;
 19481   
                 }
 19482  78 
                 break;
 19483  30 
             case IF:
 19484   
                 {
 19485  54 
                 alt124=42;
 19486   
                 }
 19487  54 
                 break;
 19488   
             case STRLANG:
 19489  30 
                 {
 19490  54 
                 alt124=43;
 19491   
                 }
 19492  24 
                 break;
 19493   
             case STRDT:
 19494   
                 {
 19495  24 
                 alt124=44;
 19496   
                 }
 19497  24 
                 break;
 19498   
             case SAMETERM:
 19499   
                 {
 19500  150 
                 alt124=45;
 19501  30 
                 }
 19502  120 
                 break;
 19503  30 
             case ISIRI:
 19504   
                 {
 19505  32 
                 alt124=46;
 19506   
                 }
 19507  32 
                 break;
 19508  30 
             case ISURI:
 19509  30 
                 {
 19510  8 
                 alt124=47;
 19511   
                 }
 19512  8 
                 break;
 19513  30 
             case ISBLANK:
 19514   
                 {
 19515  32 
                 alt124=48;
 19516  90 
                 }
 19517  92 
                 break;
 19518   
             case ISLITERAL:
 19519   
                 {
 19520  62 
                 alt124=49;
 19521   
                 }
 19522  62 
                 break;
 19523   
             case ISNUMERIC:
 19524   
                 {
 19525  16 
                 alt124=50;
 19526   
                 }
 19527  16 
                 break;
 19528  30 
             case REGEX:
 19529   
                 {
 19530  168 
                 alt124=51;
 19531  30 
                 }
 19532  168 
                 break;
 19533   
             case EXISTS:
 19534   
                 {
 19535  180 
                 alt124=52;
 19536  100 
                 }
 19537  80 
                 break;
 19538   
             case NOT:
 19539  100 
                 {
 19540  284 
                 alt124=53;
 19541   
                 }
 19542  184 
                 break;
 19543  100 
             default:
 19544  100 
                 NoViableAltException nvae =
 19545   
                     new NoViableAltException("", 124, 0, input);
 19546  100 
 
 19547  0 
                 throw nvae;
 19548  100 
 
 19549   
             }
 19550  100 
 
 19551  2228 
             switch (alt124) {
 19552   
                 case 1 :
 19553   
                     // com\\googlecode\\sparkleg\\Sparql.g:573:7: STR '(' expression ')'
 19554   
                     {
 19555  144 
                     STR389=(Token)match(input,STR,FOLLOW_STR_in_builtInCall5275);
 19556  144 
                     stream_STR.add(STR389);
 19557   
 
 19558   
 
 19559  144 
                     char_literal390=(Token)match(input,209,FOLLOW_209_in_builtInCall5277);
 19560  144 
                     stream_209.add(char_literal390);
 19561  100 
 
 19562  100 
 
 19563  144 
                     pushFollow(FOLLOW_expression_in_builtInCall5279);
 19564  244 
                     expression391=expression();
 19565   
 
 19566  144 
                     state._fsp--;
 19567   
 
 19568  144 
                     stream_expression.add(expression391.getTree());
 19569  100 
 
 19570  244 
                     char_literal392=(Token)match(input,210,FOLLOW_210_in_builtInCall5281);
 19571  144 
                     stream_210.add(char_literal392);
 19572   
 
 19573   
 
 19574  100 
                     // AST REWRITE
 19575   
                     // elements: STR, expression
 19576  100 
                     // token labels:
 19577   
                     // rule labels: retval
 19578   
                     // token list labels:
 19579   
                     // rule list labels:
 19580   
                     // wildcard labels:
 19581  144 
                     retval.tree = root_0;
 19582  244 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19583   
 
 19584  144 
                     root_0 = (Object)adaptor.nil();
 19585  100 
                     // 573:30: -> ^( STR expression )
 19586   
                     {
 19587   
                         // com\\googlecode\\sparkleg\\Sparql.g:573:33: ^( STR expression )
 19588   
                         {
 19589  174 
                         Object root_1 = (Object)adaptor.nil();
 19590  174 
                         root_1 = (Object)adaptor.becomeRoot(
 19591   
                         stream_STR.nextNode()
 19592   
                         , root_1);
 19593  30 
 
 19594  174 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19595   
 
 19596  144 
                         adaptor.addChild(root_0, root_1);
 19597  30 
                         }
 19598  30 
 
 19599   
                     }
 19600  30 
 
 19601   
 
 19602  174 
                     retval.tree = root_0;
 19603   
 
 19604  30 
                     }
 19605  174 
                     break;
 19606   
                 case 2 :
 19607   
                     // com\\googlecode\\sparkleg\\Sparql.g:574:7: LANG '(' expression ')'
 19608   
                     {
 19609  160 
                     LANG393=(Token)match(input,LANG,FOLLOW_LANG_in_builtInCall5297);
 19610  160 
                     stream_LANG.add(LANG393);
 19611   
 
 19612   
 
 19613  160 
                     char_literal394=(Token)match(input,209,FOLLOW_209_in_builtInCall5299);
 19614  160 
                     stream_209.add(char_literal394);
 19615  30 
 
 19616  30 
 
 19617  160 
                     pushFollow(FOLLOW_expression_in_builtInCall5301);
 19618  190 
                     expression395=expression();
 19619   
 
 19620  160 
                     state._fsp--;
 19621   
 
 19622  160 
                     stream_expression.add(expression395.getTree());
 19623  30 
 
 19624  190 
                     char_literal396=(Token)match(input,210,FOLLOW_210_in_builtInCall5303);
 19625  160 
                     stream_210.add(char_literal396);
 19626   
 
 19627   
 
 19628  30 
                     // AST REWRITE
 19629   
                     // elements: LANG, expression
 19630  30 
                     // token labels:
 19631   
                     // rule labels: retval
 19632   
                     // token list labels:
 19633   
                     // rule list labels:
 19634   
                     // wildcard labels:
 19635  160 
                     retval.tree = root_0;
 19636  190 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19637   
 
 19638  160 
                     root_0 = (Object)adaptor.nil();
 19639  30 
                     // 574:31: -> ^( LANG expression )
 19640   
                     {
 19641   
                         // com\\googlecode\\sparkleg\\Sparql.g:574:34: ^( LANG expression )
 19642   
                         {
 19643  162 
                         Object root_1 = (Object)adaptor.nil();
 19644  162 
                         root_1 = (Object)adaptor.becomeRoot(
 19645   
                         stream_LANG.nextNode()
 19646   
                         , root_1);
 19647  2 
 
 19648  162 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19649   
 
 19650  160 
                         adaptor.addChild(root_0, root_1);
 19651  2 
                         }
 19652  2 
 
 19653   
                     }
 19654  2 
 
 19655   
 
 19656  162 
                     retval.tree = root_0;
 19657   
 
 19658  2 
                     }
 19659  162 
                     break;
 19660   
                 case 3 :
 19661   
                     // com\\googlecode\\sparkleg\\Sparql.g:575:7: LANGMATCHES '(' expression ',' expression ')'
 19662   
                     {
 19663  120 
                     LANGMATCHES397=(Token)match(input,LANGMATCHES,FOLLOW_LANGMATCHES_in_builtInCall5319);
 19664  120 
                     stream_LANGMATCHES.add(LANGMATCHES397);
 19665   
 
 19666   
 
 19667  120 
                     char_literal398=(Token)match(input,209,FOLLOW_209_in_builtInCall5321);
 19668  120 
                     stream_209.add(char_literal398);
 19669  2 
 
 19670  2 
 
 19671  120 
                     pushFollow(FOLLOW_expression_in_builtInCall5323);
 19672  122 
                     expression399=expression();
 19673   
 
 19674  120 
                     state._fsp--;
 19675   
 
 19676  120 
                     stream_expression.add(expression399.getTree());
 19677  2 
 
 19678  122 
                     char_literal400=(Token)match(input,211,FOLLOW_211_in_builtInCall5325);
 19679  120 
                     stream_211.add(char_literal400);
 19680   
 
 19681   
 
 19682  122 
                     pushFollow(FOLLOW_expression_in_builtInCall5327);
 19683  120 
                     expression401=expression();
 19684  2 
 
 19685  120 
                     state._fsp--;
 19686   
 
 19687  120 
                     stream_expression.add(expression401.getTree());
 19688   
 
 19689  120 
                     char_literal402=(Token)match(input,210,FOLLOW_210_in_builtInCall5329);
 19690  122 
                     stream_210.add(char_literal402);
 19691   
 
 19692   
 
 19693  2 
                     // AST REWRITE
 19694   
                     // elements: expression, LANGMATCHES
 19695   
                     // token labels:
 19696   
                     // rule labels: retval
 19697  2 
                     // token list labels:
 19698  2 
                     // rule list labels:
 19699   
                     // wildcard labels:
 19700  120 
                     retval.tree = root_0;
 19701  122 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19702  2 
 
 19703  120 
                     root_0 = (Object)adaptor.nil();
 19704   
                     // 575:53: -> ^( LANGMATCHES ( expression )+ )
 19705  2 
                     {
 19706  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:575:56: ^( LANGMATCHES ( expression )+ )
 19707   
                         {
 19708  122 
                         Object root_1 = (Object)adaptor.nil();
 19709  120 
                         root_1 = (Object)adaptor.becomeRoot(
 19710  2 
                         stream_LANGMATCHES.nextNode()
 19711   
                         , root_1);
 19712  2 
 
 19713  122 
                         if ( !(stream_expression.hasNext()) ) {
 19714  0 
                             throw new RewriteEarlyExitException();
 19715   
                         }
 19716  360 
                         while ( stream_expression.hasNext() ) {
 19717  240 
                             adaptor.addChild(root_1, stream_expression.nextTree());
 19718   
 
 19719   
                         }
 19720  120 
                         stream_expression.reset();
 19721   
 
 19722  120 
                         adaptor.addChild(root_0, root_1);
 19723  2 
                         }
 19724  2 
 
 19725   
                     }
 19726  2 
 
 19727   
 
 19728  120 
                     retval.tree = root_0;
 19729   
 
 19730   
                     }
 19731  122 
                     break;
 19732  2 
                 case 4 :
 19733   
                     // com\\googlecode\\sparkleg\\Sparql.g:576:7: DATATYPE '(' expression ')'
 19734   
                     {
 19735  400 
                     DATATYPE403=(Token)match(input,DATATYPE,FOLLOW_DATATYPE_in_builtInCall5346);
 19736  402 
                     stream_DATATYPE.add(DATATYPE403);
 19737   
 
 19738  2 
 
 19739  400 
                     char_literal404=(Token)match(input,209,FOLLOW_209_in_builtInCall5348);
 19740  400 
                     stream_209.add(char_literal404);
 19741   
 
 19742   
 
 19743  400 
                     pushFollow(FOLLOW_expression_in_builtInCall5350);
 19744  402 
                     expression405=expression();
 19745   
 
 19746  400 
                     state._fsp--;
 19747  2 
 
 19748  400 
                     stream_expression.add(expression405.getTree());
 19749   
 
 19750  400 
                     char_literal406=(Token)match(input,210,FOLLOW_210_in_builtInCall5352);
 19751  404 
                     stream_210.add(char_literal406);
 19752  4 
 
 19753   
 
 19754   
                     // AST REWRITE
 19755   
                     // elements: expression, DATATYPE
 19756   
                     // token labels:
 19757   
                     // rule labels: retval
 19758  4 
                     // token list labels:
 19759  4 
                     // rule list labels:
 19760   
                     // wildcard labels:
 19761  400 
                     retval.tree = root_0;
 19762  404 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19763  4 
 
 19764  400 
                     root_0 = (Object)adaptor.nil();
 19765  4 
                     // 576:35: -> ^( DATATYPE expression )
 19766   
                     {
 19767  4 
                         // com\\googlecode\\sparkleg\\Sparql.g:576:38: ^( DATATYPE expression )
 19768   
                         {
 19769  404 
                         Object root_1 = (Object)adaptor.nil();
 19770  404 
                         root_1 = (Object)adaptor.becomeRoot(
 19771   
                         stream_DATATYPE.nextNode()
 19772   
                         , root_1);
 19773   
 
 19774  400 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19775   
 
 19776  400 
                         adaptor.addChild(root_0, root_1);
 19777   
                         }
 19778   
 
 19779   
                     }
 19780   
 
 19781   
 
 19782  400 
                     retval.tree = root_0;
 19783  4 
 
 19784  4 
                     }
 19785  400 
                     break;
 19786  4 
                 case 5 :
 19787   
                     // com\\googlecode\\sparkleg\\Sparql.g:577:7: BOUND '(' var ')'
 19788   
                     {
 19789  120 
                     BOUND407=(Token)match(input,BOUND,FOLLOW_BOUND_in_builtInCall5368);
 19790  120 
                     stream_BOUND.add(BOUND407);
 19791  4 
 
 19792  4 
 
 19793  120 
                     char_literal408=(Token)match(input,209,FOLLOW_209_in_builtInCall5370);
 19794  120 
                     stream_209.add(char_literal408);
 19795   
 
 19796  4 
 
 19797  120 
                     pushFollow(FOLLOW_var_in_builtInCall5372);
 19798  124 
                     var409=var();
 19799   
 
 19800  120 
                     state._fsp--;
 19801   
 
 19802  120 
                     stream_var.add(var409.getTree());
 19803   
 
 19804  124 
                     char_literal410=(Token)match(input,210,FOLLOW_210_in_builtInCall5374);
 19805  120 
                     stream_210.add(char_literal410);
 19806   
 
 19807  4 
 
 19808   
                     // AST REWRITE
 19809   
                     // elements: var, BOUND
 19810   
                     // token labels:
 19811  4 
                     // rule labels: retval
 19812  4 
                     // token list labels:
 19813   
                     // rule list labels:
 19814   
                     // wildcard labels:
 19815  124 
                     retval.tree = root_0;
 19816  124 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19817   
 
 19818  124 
                     root_0 = (Object)adaptor.nil();
 19819   
                     // 577:25: -> ^( BOUND var )
 19820  4 
                     {
 19821   
                         // com\\googlecode\\sparkleg\\Sparql.g:577:28: ^( BOUND var )
 19822   
                         {
 19823  120 
                         Object root_1 = (Object)adaptor.nil();
 19824  120 
                         root_1 = (Object)adaptor.becomeRoot(
 19825   
                         stream_BOUND.nextNode()
 19826   
                         , root_1);
 19827   
 
 19828  120 
                         adaptor.addChild(root_1, stream_var.nextTree());
 19829  4 
 
 19830  124 
                         adaptor.addChild(root_0, root_1);
 19831   
                         }
 19832  4 
 
 19833   
                     }
 19834   
 
 19835  4 
 
 19836  120 
                     retval.tree = root_0;
 19837   
 
 19838   
                     }
 19839  120 
                     break;
 19840   
                 case 6 :
 19841   
                     // com\\googlecode\\sparkleg\\Sparql.g:578:7: IRI '(' expression ')'
 19842  4 
                     {
 19843  8 
                     IRI411=(Token)match(input,IRI,FOLLOW_IRI_in_builtInCall5390);
 19844  8 
                     stream_IRI.add(IRI411);
 19845  4 
 
 19846   
 
 19847  8 
                     char_literal412=(Token)match(input,209,FOLLOW_209_in_builtInCall5392);
 19848  8 
                     stream_209.add(char_literal412);
 19849  2 
 
 19850  2 
 
 19851  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5394);
 19852  8 
                     expression413=expression();
 19853  2 
 
 19854  10 
                     state._fsp--;
 19855   
 
 19856  10 
                     stream_expression.add(expression413.getTree());
 19857   
 
 19858  10 
                     char_literal414=(Token)match(input,210,FOLLOW_210_in_builtInCall5396);
 19859  8 
                     stream_210.add(char_literal414);
 19860   
 
 19861   
 
 19862   
                     // AST REWRITE
 19863   
                     // elements: IRI, expression
 19864   
                     // token labels:
 19865   
                     // rule labels: retval
 19866   
                     // token list labels:
 19867  2 
                     // rule list labels:
 19868  2 
                     // wildcard labels:
 19869  8 
                     retval.tree = root_0;
 19870  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19871   
 
 19872  8 
                     root_0 = (Object)adaptor.nil();
 19873  2 
                     // 578:30: -> ^( IRI expression )
 19874   
                     {
 19875   
                         // com\\googlecode\\sparkleg\\Sparql.g:578:33: ^( IRI expression )
 19876   
                         {
 19877  8 
                         Object root_1 = (Object)adaptor.nil();
 19878  8 
                         root_1 = (Object)adaptor.becomeRoot(
 19879   
                         stream_IRI.nextNode()
 19880  2 
                         , root_1);
 19881   
 
 19882  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19883  2 
 
 19884  8 
                         adaptor.addChild(root_0, root_1);
 19885   
                         }
 19886   
 
 19887  2 
                     }
 19888  2 
 
 19889   
 
 19890  8 
                     retval.tree = root_0;
 19891  2 
 
 19892  2 
                     }
 19893  8 
                     break;
 19894   
                 case 7 :
 19895  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:579:7: URI '(' expression ')'
 19896  2 
                     {
 19897  8 
                     URI415=(Token)match(input,URI,FOLLOW_URI_in_builtInCall5412);
 19898  10 
                     stream_URI.add(URI415);
 19899   
 
 19900  2 
 
 19901  8 
                     char_literal416=(Token)match(input,209,FOLLOW_209_in_builtInCall5414);
 19902  10 
                     stream_209.add(char_literal416);
 19903  2 
 
 19904   
 
 19905  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5416);
 19906  8 
                     expression417=expression();
 19907   
 
 19908  8 
                     state._fsp--;
 19909   
 
 19910  8 
                     stream_expression.add(expression417.getTree());
 19911   
 
 19912  8 
                     char_literal418=(Token)match(input,210,FOLLOW_210_in_builtInCall5418);
 19913  10 
                     stream_210.add(char_literal418);
 19914  2 
 
 19915   
 
 19916  2 
                     // AST REWRITE
 19917   
                     // elements: expression, URI
 19918   
                     // token labels:
 19919   
                     // rule labels: retval
 19920   
                     // token list labels:
 19921  2 
                     // rule list labels:
 19922  2 
                     // wildcard labels:
 19923  8 
                     retval.tree = root_0;
 19924  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19925   
 
 19926  10 
                     root_0 = (Object)adaptor.nil();
 19927   
                     // 579:30: -> ^( URI expression )
 19928  2 
                     {
 19929   
                         // com\\googlecode\\sparkleg\\Sparql.g:579:33: ^( URI expression )
 19930   
                         {
 19931  8 
                         Object root_1 = (Object)adaptor.nil();
 19932  8 
                         root_1 = (Object)adaptor.becomeRoot(
 19933   
                         stream_URI.nextNode()
 19934  2 
                         , root_1);
 19935   
 
 19936  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19937  2 
 
 19938  8 
                         adaptor.addChild(root_0, root_1);
 19939   
                         }
 19940   
 
 19941  2 
                     }
 19942  2 
 
 19943   
 
 19944  8 
                     retval.tree = root_0;
 19945  2 
 
 19946  2 
                     }
 19947  8 
                     break;
 19948   
                 case 8 :
 19949  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:580:7: BNODE ( '(' expression ')' )
 19950  2 
                     {
 19951  16 
                     BNODE419=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5434);
 19952  18 
                     stream_BNODE.add(BNODE419);
 19953   
 
 19954  2 
 
 19955   
                     // com\\googlecode\\sparkleg\\Sparql.g:580:13: ( '(' expression ')' )
 19956  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:580:14: '(' expression ')'
 19957  2 
                     {
 19958  16 
                     char_literal420=(Token)match(input,209,FOLLOW_209_in_builtInCall5437);
 19959  16 
                     stream_209.add(char_literal420);
 19960   
 
 19961   
 
 19962  16 
                     pushFollow(FOLLOW_expression_in_builtInCall5439);
 19963  16 
                     expression421=expression();
 19964   
 
 19965  16 
                     state._fsp--;
 19966   
 
 19967  18 
                     stream_expression.add(expression421.getTree());
 19968  2 
 
 19969  16 
                     char_literal422=(Token)match(input,210,FOLLOW_210_in_builtInCall5441);
 19970  18 
                     stream_210.add(char_literal422);
 19971   
 
 19972   
 
 19973   
                     }
 19974   
 
 19975  2 
 
 19976  2 
                     // AST REWRITE
 19977   
                     // elements: BNODE, expression
 19978   
                     // token labels:
 19979   
                     // rule labels: retval
 19980  2 
                     // token list labels:
 19981   
                     // rule list labels:
 19982  2 
                     // wildcard labels:
 19983  16 
                     retval.tree = root_0;
 19984  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19985   
 
 19986  16 
                     root_0 = (Object)adaptor.nil();
 19987   
                     // 580:34: -> ^( BNODE expression )
 19988  2 
                     {
 19989   
                         // com\\googlecode\\sparkleg\\Sparql.g:580:37: ^( BNODE expression )
 19990   
                         {
 19991  18 
                         Object root_1 = (Object)adaptor.nil();
 19992  16 
                         root_1 = (Object)adaptor.becomeRoot(
 19993   
                         stream_BNODE.nextNode()
 19994   
                         , root_1);
 19995  2 
 
 19996  18 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19997   
 
 19998  16 
                         adaptor.addChild(root_0, root_1);
 19999  2 
                         }
 20000  2 
 
 20001   
                     }
 20002   
 
 20003  2 
 
 20004  18 
                     retval.tree = root_0;
 20005   
 
 20006  2 
                     }
 20007  16 
                     break;
 20008  2 
                 case 9 :
 20009   
                     // com\\googlecode\\sparkleg\\Sparql.g:581:7: BNODE nil
 20010  2 
                     {
 20011  18 
                     BNODE423=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5458);
 20012  16 
                     stream_BNODE.add(BNODE423);
 20013   
 
 20014   
 
 20015  16 
                     pushFollow(FOLLOW_nil_in_builtInCall5460);
 20016  16 
                     nil424=nil();
 20017   
 
 20018  16 
                     state._fsp--;
 20019   
 
 20020  16 
                     stream_nil.add(nil424.getTree());
 20021  2 
 
 20022  2 
                     // AST REWRITE
 20023   
                     // elements: BNODE
 20024  2 
                     // token labels:
 20025   
                     // rule labels: retval
 20026   
                     // token list labels:
 20027   
                     // rule list labels:
 20028   
                     // wildcard labels:
 20029  18 
                     retval.tree = root_0;
 20030  18 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20031   
 
 20032  16 
                     root_0 = (Object)adaptor.nil();
 20033   
                     // 581:17: -> BNODE
 20034  2 
                     {
 20035  16 
                         adaptor.addChild(root_0,
 20036  2 
                         stream_BNODE.nextNode()
 20037   
                         );
 20038   
 
 20039   
                     }
 20040   
 
 20041   
 
 20042  18 
                     retval.tree = root_0;
 20043   
 
 20044   
                     }
 20045  18 
                     break;
 20046   
                 case 10 :
 20047   
                     // com\\googlecode\\sparkleg\\Sparql.g:582:7: RAND nil
 20048   
                     {
 20049  10 
                     RAND425=(Token)match(input,RAND,FOLLOW_RAND_in_builtInCall5472);
 20050  10 
                     stream_RAND.add(RAND425);
 20051   
 
 20052   
 
 20053  10 
                     pushFollow(FOLLOW_nil_in_builtInCall5474);
 20054  10 
                     nil426=nil();
 20055   
 
 20056  8 
                     state._fsp--;
 20057  2 
 
 20058  10 
                     stream_nil.add(nil426.getTree());
 20059   
 
 20060  2 
                     // AST REWRITE
 20061   
                     // elements: RAND
 20062  2 
                     // token labels:
 20063   
                     // rule labels: retval
 20064  2 
                     // token list labels:
 20065  2 
                     // rule list labels:
 20066   
                     // wildcard labels:
 20067  8 
                     retval.tree = root_0;
 20068  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20069   
 
 20070  8 
                     root_0 = (Object)adaptor.nil();
 20071   
                     // 582:16: -> RAND
 20072   
                     {
 20073  8 
                         adaptor.addChild(root_0,
 20074   
                         stream_RAND.nextNode()
 20075  2 
                         );
 20076  2 
 
 20077   
                     }
 20078  2 
 
 20079   
 
 20080  8 
                     retval.tree = root_0;
 20081   
 
 20082   
                     }
 20083  10 
                     break;
 20084  2 
                 case 11 :
 20085   
                     // com\\googlecode\\sparkleg\\Sparql.g:583:7: ABS '(' expression ')'
 20086   
                     {
 20087  8 
                     ABS427=(Token)match(input,ABS,FOLLOW_ABS_in_builtInCall5486);
 20088  10 
                     stream_ABS.add(ABS427);
 20089   
 
 20090  2 
 
 20091  8 
                     char_literal428=(Token)match(input,209,FOLLOW_209_in_builtInCall5488);
 20092  8 
                     stream_209.add(char_literal428);
 20093   
 
 20094   
 
 20095  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5490);
 20096  10 
                     expression429=expression();
 20097   
 
 20098  8 
                     state._fsp--;
 20099  2 
 
 20100  8 
                     stream_expression.add(expression429.getTree());
 20101   
 
 20102  8 
                     char_literal430=(Token)match(input,210,FOLLOW_210_in_builtInCall5492);
 20103  18 
                     stream_210.add(char_literal430);
 20104  10 
 
 20105   
 
 20106   
                     // AST REWRITE
 20107  10 
                     // elements: ABS, expression
 20108  10 
                     // token labels:
 20109   
                     // rule labels: retval
 20110  10 
                     // token list labels:
 20111   
                     // rule list labels:
 20112  10 
                     // wildcard labels:
 20113  8 
                     retval.tree = root_0;
 20114  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20115   
 
 20116  8 
                     root_0 = (Object)adaptor.nil();
 20117   
                     // 583:30: -> ^( ABS expression )
 20118   
                     {
 20119   
                         // com\\googlecode\\sparkleg\\Sparql.g:583:33: ^( ABS expression )
 20120   
                         {
 20121  18 
                         Object root_1 = (Object)adaptor.nil();
 20122  18 
                         root_1 = (Object)adaptor.becomeRoot(
 20123   
                         stream_ABS.nextNode()
 20124  10 
                         , root_1);
 20125   
 
 20126  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20127   
 
 20128  8 
                         adaptor.addChild(root_0, root_1);
 20129  10 
                         }
 20130  10 
 
 20131   
                     }
 20132   
 
 20133   
 
 20134  18 
                     retval.tree = root_0;
 20135   
 
 20136  10 
                     }
 20137  8 
                     break;
 20138   
                 case 12 :
 20139   
                     // com\\googlecode\\sparkleg\\Sparql.g:584:7: CEIL '(' expression ')'
 20140   
                     {
 20141  8 
                     CEIL431=(Token)match(input,CEIL,FOLLOW_CEIL_in_builtInCall5508);
 20142  18 
                     stream_CEIL.add(CEIL431);
 20143   
 
 20144   
 
 20145  18 
                     char_literal432=(Token)match(input,209,FOLLOW_209_in_builtInCall5510);
 20146  8 
                     stream_209.add(char_literal432);
 20147   
 
 20148   
 
 20149  12 
                     pushFollow(FOLLOW_expression_in_builtInCall5512);
 20150  12 
                     expression433=expression();
 20151   
 
 20152  12 
                     state._fsp--;
 20153   
 
 20154  12 
                     stream_expression.add(expression433.getTree());
 20155   
 
 20156  8 
                     char_literal434=(Token)match(input,210,FOLLOW_210_in_builtInCall5514);
 20157  8 
                     stream_210.add(char_literal434);
 20158   
 
 20159   
 
 20160   
                     // AST REWRITE
 20161   
                     // elements: expression, CEIL
 20162   
                     // token labels:
 20163  4 
                     // rule labels: retval
 20164  4 
                     // token list labels:
 20165   
                     // rule list labels:
 20166  4 
                     // wildcard labels:
 20167  8 
                     retval.tree = root_0;
 20168  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20169  4 
 
 20170  8 
                     root_0 = (Object)adaptor.nil();
 20171   
                     // 584:31: -> ^( CEIL expression )
 20172   
                     {
 20173   
                         // com\\googlecode\\sparkleg\\Sparql.g:584:34: ^( CEIL expression )
 20174  4 
                         {
 20175  8 
                         Object root_1 = (Object)adaptor.nil();
 20176  8 
                         root_1 = (Object)adaptor.becomeRoot(
 20177  4 
                         stream_CEIL.nextNode()
 20178   
                         , root_1);
 20179   
 
 20180  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20181  6 
 
 20182  14 
                         adaptor.addChild(root_0, root_1);
 20183   
                         }
 20184  6 
 
 20185   
                     }
 20186  6 
 
 20187   
 
 20188  8 
                     retval.tree = root_0;
 20189   
 
 20190   
                     }
 20191  8 
                     break;
 20192   
                 case 13 :
 20193   
                     // com\\googlecode\\sparkleg\\Sparql.g:585:7: FLOOR '(' expression ')'
 20194   
                     {
 20195  14 
                     FLOOR435=(Token)match(input,FLOOR,FOLLOW_FLOOR_in_builtInCall5530);
 20196  14 
                     stream_FLOOR.add(FLOOR435);
 20197   
 
 20198  6 
 
 20199  8 
                     char_literal436=(Token)match(input,209,FOLLOW_209_in_builtInCall5532);
 20200  8 
                     stream_209.add(char_literal436);
 20201  6 
 
 20202   
 
 20203  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5534);
 20204  8 
                     expression437=expression();
 20205   
 
 20206  14 
                     state._fsp--;
 20207   
 
 20208  8 
                     stream_expression.add(expression437.getTree());
 20209  6 
 
 20210  8 
                     char_literal438=(Token)match(input,210,FOLLOW_210_in_builtInCall5536);
 20211  8 
                     stream_210.add(char_literal438);
 20212   
 
 20213  2 
 
 20214  2 
                     // AST REWRITE
 20215   
                     // elements: FLOOR, expression
 20216   
                     // token labels:
 20217  2 
                     // rule labels: retval
 20218  2 
                     // token list labels:
 20219   
                     // rule list labels:
 20220   
                     // wildcard labels:
 20221  10 
                     retval.tree = root_0;
 20222  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20223   
 
 20224  10 
                     root_0 = (Object)adaptor.nil();
 20225   
                     // 585:32: -> ^( FLOOR expression )
 20226  2 
                     {
 20227   
                         // com\\googlecode\\sparkleg\\Sparql.g:585:35: ^( FLOOR expression )
 20228  2 
                         {
 20229  10 
                         Object root_1 = (Object)adaptor.nil();
 20230  8 
                         root_1 = (Object)adaptor.becomeRoot(
 20231   
                         stream_FLOOR.nextNode()
 20232   
                         , root_1);
 20233   
 
 20234  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20235   
 
 20236  8 
                         adaptor.addChild(root_0, root_1);
 20237   
                         }
 20238   
 
 20239  2 
                     }
 20240  2 
 
 20241   
 
 20242  10 
                     retval.tree = root_0;
 20243   
 
 20244   
                     }
 20245  8 
                     break;
 20246   
                 case 14 :
 20247  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:586:7: ROUND '(' expression ')'
 20248  2 
                     {
 20249  8 
                     ROUND439=(Token)match(input,ROUND,FOLLOW_ROUND_in_builtInCall5552);
 20250  8 
                     stream_ROUND.add(ROUND439);
 20251   
 
 20252  2 
 
 20253  8 
                     char_literal440=(Token)match(input,209,FOLLOW_209_in_builtInCall5554);
 20254  10 
                     stream_209.add(char_literal440);
 20255   
 
 20256   
 
 20257  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5556);
 20258  8 
                     expression441=expression();
 20259   
 
 20260  10 
                     state._fsp--;
 20261   
 
 20262  8 
                     stream_expression.add(expression441.getTree());
 20263  2 
 
 20264  8 
                     char_literal442=(Token)match(input,210,FOLLOW_210_in_builtInCall5558);
 20265  8 
                     stream_210.add(char_literal442);
 20266   
 
 20267  2 
 
 20268  2 
                     // AST REWRITE
 20269   
                     // elements: ROUND, expression
 20270   
                     // token labels:
 20271  2 
                     // rule labels: retval
 20272  2 
                     // token list labels:
 20273   
                     // rule list labels:
 20274   
                     // wildcard labels:
 20275  10 
                     retval.tree = root_0;
 20276  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20277   
 
 20278  10 
                     root_0 = (Object)adaptor.nil();
 20279   
                     // 586:32: -> ^( ROUND expression )
 20280  2 
                     {
 20281   
                         // com\\googlecode\\sparkleg\\Sparql.g:586:35: ^( ROUND expression )
 20282  2 
                         {
 20283  10 
                         Object root_1 = (Object)adaptor.nil();
 20284  8 
                         root_1 = (Object)adaptor.becomeRoot(
 20285   
                         stream_ROUND.nextNode()
 20286   
                         , root_1);
 20287   
 
 20288  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20289   
 
 20290  8 
                         adaptor.addChild(root_0, root_1);
 20291   
                         }
 20292   
 
 20293  2 
                     }
 20294  2 
 
 20295   
 
 20296  10 
                     retval.tree = root_0;
 20297   
 
 20298   
                     }
 20299  8 
                     break;
 20300   
                 case 15 :
 20301  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:587:7: CONCAT expressionList
 20302  2 
                     {
 20303  40 
                     CONCAT443=(Token)match(input,CONCAT,FOLLOW_CONCAT_in_builtInCall5574);
 20304  40 
                     stream_CONCAT.add(CONCAT443);
 20305   
 
 20306  2 
 
 20307  40 
                     pushFollow(FOLLOW_expressionList_in_builtInCall5576);
 20308  42 
                     expressionList444=expressionList();
 20309   
 
 20310  40 
                     state._fsp--;
 20311   
 
 20312  40 
                     stream_expressionList.add(expressionList444.getTree());
 20313   
 
 20314  2 
                     // AST REWRITE
 20315   
                     // elements: expressionList, CONCAT
 20316   
                     // token labels:
 20317  2 
                     // rule labels: retval
 20318   
                     // token list labels:
 20319   
                     // rule list labels:
 20320   
                     // wildcard labels:
 20321  42 
                     retval.tree = root_0;
 20322  42 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20323   
 
 20324  40 
                     root_0 = (Object)adaptor.nil();
 20325  2 
                     // 587:29: -> ^( CONCAT expressionList )
 20326  2 
                     {
 20327   
                         // com\\googlecode\\sparkleg\\Sparql.g:587:32: ^( CONCAT expressionList )
 20328   
                         {
 20329  42 
                         Object root_1 = (Object)adaptor.nil();
 20330  42 
                         root_1 = (Object)adaptor.becomeRoot(
 20331   
                         stream_CONCAT.nextNode()
 20332  2 
                         , root_1);
 20333   
 
 20334  42 
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 20335   
 
 20336  42 
                         adaptor.addChild(root_0, root_1);
 20337  2 
                         }
 20338   
 
 20339   
                     }
 20340   
 
 20341   
 
 20342  40 
                     retval.tree = root_0;
 20343   
 
 20344   
                     }
 20345  40 
                     break;
 20346   
                 case 16 :
 20347  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:588:7: subStringExpression
 20348  2 
                     {
 20349  16 
                     pushFollow(FOLLOW_subStringExpression_in_builtInCall5592);
 20350  18 
                     subStringExpression445=subStringExpression();
 20351   
 
 20352  16 
                     state._fsp--;
 20353   
 
 20354  16 
                     stream_subStringExpression.add(subStringExpression445.getTree());
 20355  2 
 
 20356  2 
                     // AST REWRITE
 20357   
                     // elements: subStringExpression
 20358   
                     // token labels:
 20359   
                     // rule labels: retval
 20360  2 
                     // token list labels:
 20361   
                     // rule list labels:
 20362  2 
                     // wildcard labels:
 20363  16 
                     retval.tree = root_0;
 20364  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20365   
 
 20366  16 
                     root_0 = (Object)adaptor.nil();
 20367   
                     // 588:27: -> subStringExpression
 20368  2 
                     {
 20369  16 
                         adaptor.addChild(root_0, stream_subStringExpression.nextTree());
 20370   
 
 20371  2 
                     }
 20372   
 
 20373   
 
 20374  16 
                     retval.tree = root_0;
 20375  2 
 
 20376  2 
                     }
 20377  16 
                     break;
 20378   
                 case 17 :
 20379  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:589:7: strReplaceExpression
 20380  2 
                     {
 20381  24 
                     pushFollow(FOLLOW_strReplaceExpression_in_builtInCall5604);
 20382  24 
                     strReplaceExpression446=strReplaceExpression();
 20383  2 
 
 20384  26 
                     state._fsp--;
 20385   
 
 20386  26 
                     stream_strReplaceExpression.add(strReplaceExpression446.getTree());
 20387   
 
 20388  2 
                     // AST REWRITE
 20389   
                     // elements: strReplaceExpression
 20390  2 
                     // token labels:
 20391  2 
                     // rule labels: retval
 20392   
                     // token list labels:
 20393   
                     // rule list labels:
 20394   
                     // wildcard labels:
 20395  24 
                     retval.tree = root_0;
 20396  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20397   
 
 20398  24 
                     root_0 = (Object)adaptor.nil();
 20399   
                     // 589:28: -> strReplaceExpression
 20400   
                     {
 20401  26 
                         adaptor.addChild(root_0, stream_strReplaceExpression.nextTree());
 20402  2 
 
 20403   
                     }
 20404  2 
 
 20405   
 
 20406  24 
                     retval.tree = root_0;
 20407   
 
 20408   
                     }
 20409  26 
                     break;
 20410  2 
                 case 18 :
 20411   
                     // com\\googlecode\\sparkleg\\Sparql.g:590:7: STRLEN '(' expression ')'
 20412   
                     {
 20413  8 
                     STRLEN447=(Token)match(input,STRLEN,FOLLOW_STRLEN_in_builtInCall5616);
 20414  10 
                     stream_STRLEN.add(STRLEN447);
 20415   
 
 20416  2 
 
 20417  8 
                     char_literal448=(Token)match(input,209,FOLLOW_209_in_builtInCall5618);
 20418  8 
                     stream_209.add(char_literal448);
 20419   
 
 20420   
 
 20421  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5620);
 20422  10 
                     expression449=expression();
 20423   
 
 20424  8 
                     state._fsp--;
 20425  2 
 
 20426  8 
                     stream_expression.add(expression449.getTree());
 20427   
 
 20428  8 
                     char_literal450=(Token)match(input,210,FOLLOW_210_in_builtInCall5622);
 20429  10 
                     stream_210.add(char_literal450);
 20430  2 
 
 20431   
 
 20432   
                     // AST REWRITE
 20433  2 
                     // elements: STRLEN, expression
 20434  2 
                     // token labels:
 20435   
                     // rule labels: retval
 20436   
                     // token list labels:
 20437  2 
                     // rule list labels:
 20438  2 
                     // wildcard labels:
 20439  8 
                     retval.tree = root_0;
 20440  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20441   
 
 20442  10 
                     root_0 = (Object)adaptor.nil();
 20443   
                     // 590:33: -> ^( STRLEN expression )
 20444  2 
                     {
 20445  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:590:36: ^( STRLEN expression )
 20446   
                         {
 20447  8 
                         Object root_1 = (Object)adaptor.nil();
 20448  10 
                         root_1 = (Object)adaptor.becomeRoot(
 20449  2 
                         stream_STRLEN.nextNode()
 20450   
                         , root_1);
 20451  2 
 
 20452  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20453  2 
 
 20454  8 
                         adaptor.addChild(root_0, root_1);
 20455  2 
                         }
 20456  2 
 
 20457   
                     }
 20458   
 
 20459   
 
 20460  8 
                     retval.tree = root_0;
 20461   
 
 20462   
                     }
 20463  8 
                     break;
 20464   
                 case 19 :
 20465   
                     // com\\googlecode\\sparkleg\\Sparql.g:591:7: UCASE '(' expression ')'
 20466  2 
                     {
 20467  10 
                     UCASE451=(Token)match(input,UCASE,FOLLOW_UCASE_in_builtInCall5638);
 20468  8 
                     stream_UCASE.add(UCASE451);
 20469  2 
 
 20470   
 
 20471  8 
                     char_literal452=(Token)match(input,209,FOLLOW_209_in_builtInCall5640);
 20472  8 
                     stream_209.add(char_literal452);
 20473   
 
 20474  2 
 
 20475  10 
                     pushFollow(FOLLOW_expression_in_builtInCall5642);
 20476  8 
                     expression453=expression();
 20477   
 
 20478  8 
                     state._fsp--;
 20479  2 
 
 20480  8 
                     stream_expression.add(expression453.getTree());
 20481  2 
 
 20482  8 
                     char_literal454=(Token)match(input,210,FOLLOW_210_in_builtInCall5644);
 20483  10 
                     stream_210.add(char_literal454);
 20484   
 
 20485   
 
 20486   
                     // AST REWRITE
 20487   
                     // elements: expression, UCASE
 20488   
                     // token labels:
 20489  2 
                     // rule labels: retval
 20490   
                     // token list labels:
 20491   
                     // rule list labels:
 20492  2 
                     // wildcard labels:
 20493  8 
                     retval.tree = root_0;
 20494  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20495   
 
 20496  10 
                     root_0 = (Object)adaptor.nil();
 20497  2 
                     // 591:32: -> ^( UCASE expression )
 20498   
                     {
 20499   
                         // com\\googlecode\\sparkleg\\Sparql.g:591:35: ^( UCASE expression )
 20500  2 
                         {
 20501  10 
                         Object root_1 = (Object)adaptor.nil();
 20502  8 
                         root_1 = (Object)adaptor.becomeRoot(
 20503   
                         stream_UCASE.nextNode()
 20504  2 
                         , root_1);
 20505  2 
 
 20506  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20507  2 
 
 20508  8 
                         adaptor.addChild(root_0, root_1);
 20509  2 
                         }
 20510   
 
 20511  2 
                     }
 20512  2 
 
 20513   
 
 20514  8 
                     retval.tree = root_0;
 20515  2 
 
 20516  2 
                     }
 20517  8 
                     break;
 20518  2 
                 case 20 :
 20519   
                     // com\\googlecode\\sparkleg\\Sparql.g:592:7: LCASE '(' expression ')'
 20520  2 
                     {
 20521  8 
                     LCASE455=(Token)match(input,LCASE,FOLLOW_LCASE_in_builtInCall5660);
 20522  10 
                     stream_LCASE.add(LCASE455);
 20523  2 
 
 20524   
 
 20525  8 
                     char_literal456=(Token)match(input,209,FOLLOW_209_in_builtInCall5662);
 20526  8 
                     stream_209.add(char_literal456);
 20527   
 
 20528   
 
 20529  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5664);
 20530  8 
                     expression457=expression();
 20531   
 
 20532  8 
                     state._fsp--;
 20533  2 
 
 20534  10 
                     stream_expression.add(expression457.getTree());
 20535   
 
 20536  10 
                     char_literal458=(Token)match(input,210,FOLLOW_210_in_builtInCall5666);
 20537  8 
                     stream_210.add(char_literal458);
 20538   
 
 20539   
 
 20540   
                     // AST REWRITE
 20541  2 
                     // elements: LCASE, expression
 20542  2 
                     // token labels:
 20543   
                     // rule labels: retval
 20544   
                     // token list labels:
 20545   
                     // rule list labels:
 20546  2 
                     // wildcard labels:
 20547  8 
                     retval.tree = root_0;
 20548  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20549   
 
 20550  10 
                     root_0 = (Object)adaptor.nil();
 20551   
                     // 592:32: -> ^( LCASE expression )
 20552   
                     {
 20553   
                         // com\\googlecode\\sparkleg\\Sparql.g:592:35: ^( LCASE expression )
 20554   
                         {
 20555  8 
                         Object root_1 = (Object)adaptor.nil();
 20556  10 
                         root_1 = (Object)adaptor.becomeRoot(
 20557   
                         stream_LCASE.nextNode()
 20558   
                         , root_1);
 20559  2 
 
 20560  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20561   
 
 20562  8 
                         adaptor.addChild(root_0, root_1);
 20563  2 
                         }
 20564  2 
 
 20565   
                     }
 20566   
 
 20567  2 
 
 20568  10 
                     retval.tree = root_0;
 20569   
 
 20570   
                     }
 20571  10 
                     break;
 20572  2 
                 case 21 :
 20573   
                     // com\\googlecode\\sparkleg\\Sparql.g:593:7: ENCODE_FOR_URI '(' expression ')'
 20574  2 
                     {
 20575  8 
                     ENCODE_FOR_URI459=(Token)match(input,ENCODE_FOR_URI,FOLLOW_ENCODE_FOR_URI_in_builtInCall5682);
 20576  10 
                     stream_ENCODE_FOR_URI.add(ENCODE_FOR_URI459);
 20577   
 
 20578  2 
 
 20579  10 
                     char_literal460=(Token)match(input,209,FOLLOW_209_in_builtInCall5684);
 20580  8 
                     stream_209.add(char_literal460);
 20581   
 
 20582  2 
 
 20583  10 
                     pushFollow(FOLLOW_expression_in_builtInCall5686);
 20584  8 
                     expression461=expression();
 20585  2 
 
 20586  8 
                     state._fsp--;
 20587  2 
 
 20588  8 
                     stream_expression.add(expression461.getTree());
 20589  2 
 
 20590  10 
                     char_literal462=(Token)match(input,210,FOLLOW_210_in_builtInCall5688);
 20591  8 
                     stream_210.add(char_literal462);
 20592   
 
 20593   
 
 20594   
                     // AST REWRITE
 20595   
                     // elements: expression, ENCODE_FOR_URI
 20596   
                     // token labels:
 20597   
                     // rule labels: retval
 20598   
                     // token list labels:
 20599   
                     // rule list labels:
 20600  2 
                     // wildcard labels:
 20601  10 
                     retval.tree = root_0;
 20602  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20603  2 
 
 20604  8 
                     root_0 = (Object)adaptor.nil();
 20605   
                     // 593:41: -> ^( ENCODE_FOR_URI expression )
 20606   
                     {
 20607   
                         // com\\googlecode\\sparkleg\\Sparql.g:593:44: ^( ENCODE_FOR_URI expression )
 20608  2 
                         {
 20609  10 
                         Object root_1 = (Object)adaptor.nil();
 20610  8 
                         root_1 = (Object)adaptor.becomeRoot(
 20611   
                         stream_ENCODE_FOR_URI.nextNode()
 20612   
                         , root_1);
 20613  2 
 
 20614  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20615  2 
 
 20616  8 
                         adaptor.addChild(root_0, root_1);
 20617  2 
                         }
 20618   
 
 20619   
                     }
 20620   
 
 20621   
 
 20622  8 
                     retval.tree = root_0;
 20623  2 
 
 20624   
                     }
 20625  8 
                     break;
 20626  2 
                 case 22 :
 20627   
                     // com\\googlecode\\sparkleg\\Sparql.g:594:7: CONTAINS '(' expression ',' expression ')'
 20628   
                     {
 20629  8 
                     CONTAINS463=(Token)match(input,CONTAINS,FOLLOW_CONTAINS_in_builtInCall5704);
 20630  10 
                     stream_CONTAINS.add(CONTAINS463);
 20631  2 
 
 20632   
 
 20633  8 
                     char_literal464=(Token)match(input,209,FOLLOW_209_in_builtInCall5706);
 20634  10 
                     stream_209.add(char_literal464);
 20635  2 
 
 20636   
 
 20637  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5708);
 20638  10 
                     expression465=expression();
 20639  2 
 
 20640  8 
                     state._fsp--;
 20641  2 
 
 20642  8 
                     stream_expression.add(expression465.getTree());
 20643  2 
 
 20644  8 
                     char_literal466=(Token)match(input,211,FOLLOW_211_in_builtInCall5710);
 20645  10 
                     stream_211.add(char_literal466);
 20646  2 
 
 20647   
 
 20648  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5712);
 20649  10 
                     expression467=expression();
 20650  2 
 
 20651  8 
                     state._fsp--;
 20652  2 
 
 20653  8 
                     stream_expression.add(expression467.getTree());
 20654  2 
 
 20655  8 
                     char_literal468=(Token)match(input,210,FOLLOW_210_in_builtInCall5714);
 20656  10 
                     stream_210.add(char_literal468);
 20657  2 
 
 20658   
 
 20659   
                     // AST REWRITE
 20660   
                     // elements: CONTAINS, expression, expression
 20661   
                     // token labels:
 20662   
                     // rule labels: retval
 20663   
                     // token list labels:
 20664   
                     // rule list labels:
 20665   
                     // wildcard labels:
 20666  8 
                     retval.tree = root_0;
 20667  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20668  2 
 
 20669  8 
                     root_0 = (Object)adaptor.nil();
 20670  2 
                     // 594:50: -> ^( CONTAINS expression expression )
 20671   
                     {
 20672   
                         // com\\googlecode\\sparkleg\\Sparql.g:594:53: ^( CONTAINS expression expression )
 20673   
                         {
 20674  8 
                         Object root_1 = (Object)adaptor.nil();
 20675  10 
                         root_1 = (Object)adaptor.becomeRoot(
 20676  2 
                         stream_CONTAINS.nextNode()
 20677   
                         , root_1);
 20678   
 
 20679  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20680  2 
 
 20681  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20682  2 
 
 20683  8 
                         adaptor.addChild(root_0, root_1);
 20684  2 
                         }
 20685   
 
 20686   
                     }
 20687   
 
 20688   
 
 20689  8 
                     retval.tree = root_0;
 20690  2 
 
 20691   
                     }
 20692  8 
                     break;
 20693  2 
                 case 23 :
 20694   
                     // com\\googlecode\\sparkleg\\Sparql.g:595:7: STRSTARTS '(' expression ',' expression ')'
 20695   
                     {
 20696  8 
                     STRSTARTS469=(Token)match(input,STRSTARTS,FOLLOW_STRSTARTS_in_builtInCall5732);
 20697  10 
                     stream_STRSTARTS.add(STRSTARTS469);
 20698  2 
 
 20699   
 
 20700  8 
                     char_literal470=(Token)match(input,209,FOLLOW_209_in_builtInCall5734);
 20701  10 
                     stream_209.add(char_literal470);
 20702  2 
 
 20703   
 
 20704  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5736);
 20705  10 
                     expression471=expression();
 20706  2 
 
 20707  8 
                     state._fsp--;
 20708  2 
 
 20709  8 
                     stream_expression.add(expression471.getTree());
 20710  2 
 
 20711  8 
                     char_literal472=(Token)match(input,211,FOLLOW_211_in_builtInCall5738);
 20712  10 
                     stream_211.add(char_literal472);
 20713  2 
 
 20714   
 
 20715  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5740);
 20716  10 
                     expression473=expression();
 20717  2 
 
 20718  8 
                     state._fsp--;
 20719  2 
 
 20720  8 
                     stream_expression.add(expression473.getTree());
 20721  2 
 
 20722  8 
                     char_literal474=(Token)match(input,210,FOLLOW_210_in_builtInCall5742);
 20723  10 
                     stream_210.add(char_literal474);
 20724  2 
 
 20725   
 
 20726   
                     // AST REWRITE
 20727   
                     // elements: STRSTARTS, expression, expression
 20728   
                     // token labels:
 20729   
                     // rule labels: retval
 20730   
                     // token list labels:
 20731   
                     // rule list labels:
 20732   
                     // wildcard labels:
 20733  8 
                     retval.tree = root_0;
 20734  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20735  2 
 
 20736  8 
                     root_0 = (Object)adaptor.nil();
 20737  2 
                     // 595:51: -> ^( STRSTARTS expression expression )
 20738   
                     {
 20739   
                         // com\\googlecode\\sparkleg\\Sparql.g:595:54: ^( STRSTARTS expression expression )
 20740   
                         {
 20741  8 
                         Object root_1 = (Object)adaptor.nil();
 20742  10 
                         root_1 = (Object)adaptor.becomeRoot(
 20743  2 
                         stream_STRSTARTS.nextNode()
 20744   
                         , root_1);
 20745   
 
 20746  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20747  2 
 
 20748  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20749  2 
 
 20750  8 
                         adaptor.addChild(root_0, root_1);
 20751  2 
                         }
 20752   
 
 20753   
                     }
 20754   
 
 20755   
 
 20756  8 
                     retval.tree = root_0;
 20757  2 
 
 20758   
                     }
 20759  8 
                     break;
 20760  2 
                 case 24 :
 20761   
                     // com\\googlecode\\sparkleg\\Sparql.g:596:7: STRENDS '(' expression ',' expression ')'
 20762   
                     {
 20763  8 
                     STRENDS475=(Token)match(input,STRENDS,FOLLOW_STRENDS_in_builtInCall5760);
 20764  10 
                     stream_STRENDS.add(STRENDS475);
 20765  2 
 
 20766   
 
 20767  8 
                     char_literal476=(Token)match(input,209,FOLLOW_209_in_builtInCall5762);
 20768  10 
                     stream_209.add(char_literal476);
 20769  2 
 
 20770   
 
 20771  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5764);
 20772  10 
                     expression477=expression();
 20773  2 
 
 20774  8 
                     state._fsp--;
 20775  2 
 
 20776  8 
                     stream_expression.add(expression477.getTree());
 20777  2 
 
 20778  8 
                     char_literal478=(Token)match(input,211,FOLLOW_211_in_builtInCall5766);
 20779  10 
                     stream_211.add(char_literal478);
 20780  2 
 
 20781   
 
 20782  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5768);
 20783  8 
                     expression479=expression();
 20784   
 
 20785  8 
                     state._fsp--;
 20786   
 
 20787  8 
                     stream_expression.add(expression479.getTree());
 20788   
 
 20789  8 
                     char_literal480=(Token)match(input,210,FOLLOW_210_in_builtInCall5770);
 20790  10 
                     stream_210.add(char_literal480);
 20791  2 
 
 20792   
 
 20793  2 
                     // AST REWRITE
 20794   
                     // elements: expression, STRENDS, expression
 20795   
                     // token labels:
 20796   
                     // rule labels: retval
 20797   
                     // token list labels:
 20798  2 
                     // rule list labels:
 20799  2 
                     // wildcard labels:
 20800  8 
                     retval.tree = root_0;
 20801  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20802   
 
 20803  10 
                     root_0 = (Object)adaptor.nil();
 20804   
                     // 596:49: -> ^( STRENDS expression expression )
 20805  2 
                     {
 20806   
                         // com\\googlecode\\sparkleg\\Sparql.g:596:52: ^( STRENDS expression expression )
 20807   
                         {
 20808  8 
                         Object root_1 = (Object)adaptor.nil();
 20809  8 
                         root_1 = (Object)adaptor.becomeRoot(
 20810   
                         stream_STRENDS.nextNode()
 20811  2 
                         , root_1);
 20812   
 
 20813  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20814  2 
 
 20815  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20816   
 
 20817  8 
                         adaptor.addChild(root_0, root_1);
 20818  2 
                         }
 20819  2 
 
 20820   
                     }
 20821   
 
 20822  2 
 
 20823  10 
                     retval.tree = root_0;
 20824   
 
 20825   
                     }
 20826  10 
                     break;
 20827  2 
                 case 25 :
 20828   
                     // com\\googlecode\\sparkleg\\Sparql.g:597:7: STRBEFORE '(' expression ',' expression ')'
 20829  2 
                     {
 20830  8 
                     STRBEFORE481=(Token)match(input,STRBEFORE,FOLLOW_STRBEFORE_in_builtInCall5788);
 20831  10 
                     stream_STRBEFORE.add(STRBEFORE481);
 20832   
 
 20833  2 
 
 20834  10 
                     char_literal482=(Token)match(input,209,FOLLOW_209_in_builtInCall5790);
 20835  8 
                     stream_209.add(char_literal482);
 20836   
 
 20837   
 
 20838  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5792);
 20839  8 
                     expression483=expression();
 20840   
 
 20841  8 
                     state._fsp--;
 20842   
 
 20843  8 
                     stream_expression.add(expression483.getTree());
 20844  2 
 
 20845  10 
                     char_literal484=(Token)match(input,211,FOLLOW_211_in_builtInCall5794);
 20846  8 
                     stream_211.add(char_literal484);
 20847  2 
 
 20848   
 
 20849  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5796);
 20850  8 
                     expression485=expression();
 20851   
 
 20852  10 
                     state._fsp--;
 20853  2 
 
 20854  8 
                     stream_expression.add(expression485.getTree());
 20855   
 
 20856  8 
                     char_literal486=(Token)match(input,210,FOLLOW_210_in_builtInCall5798);
 20857  10 
                     stream_210.add(char_literal486);
 20858   
 
 20859  2 
 
 20860   
                     // AST REWRITE
 20861   
                     // elements: STRBEFORE, expression, expression
 20862   
                     // token labels:
 20863   
                     // rule labels: retval
 20864   
                     // token list labels:
 20865  2 
                     // rule list labels:
 20866   
                     // wildcard labels:
 20867  8 
                     retval.tree = root_0;
 20868  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20869   
 
 20870  8 
                     root_0 = (Object)adaptor.nil();
 20871   
                     // 597:51: -> ^( STRBEFORE expression expression )
 20872  2 
                     {
 20873  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:597:54: ^( STRBEFORE expression expression )
 20874   
                         {
 20875  8 
                         Object root_1 = (Object)adaptor.nil();
 20876  10 
                         root_1 = (Object)adaptor.becomeRoot(
 20877  2 
                         stream_STRBEFORE.nextNode()
 20878   
                         , root_1);
 20879   
 
 20880  10 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20881  2 
 
 20882  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20883  2 
 
 20884  8 
                         adaptor.addChild(root_0, root_1);
 20885  2 
                         }
 20886   
 
 20887  2 
                     }
 20888  2 
 
 20889   
 
 20890  8 
                     retval.tree = root_0;
 20891   
 
 20892   
                     }
 20893  8 
                     break;
 20894   
                 case 26 :
 20895   
                     // com\\googlecode\\sparkleg\\Sparql.g:598:7: STRAFTER '(' expression ',' expression ')'
 20896   
                     {
 20897  8 
                     STRAFTER487=(Token)match(input,STRAFTER,FOLLOW_STRAFTER_in_builtInCall5816);
 20898  10 
                     stream_STRAFTER.add(STRAFTER487);
 20899  2 
 
 20900   
 
 20901  10 
                     char_literal488=(Token)match(input,209,FOLLOW_209_in_builtInCall5818);
 20902  8 
                     stream_209.add(char_literal488);
 20903   
 
 20904   
 
 20905  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5820);
 20906  10 
                     expression489=expression();
 20907  2 
 
 20908  8 
                     state._fsp--;
 20909   
 
 20910  8 
                     stream_expression.add(expression489.getTree());
 20911  2 
 
 20912  8 
                     char_literal490=(Token)match(input,211,FOLLOW_211_in_builtInCall5822);
 20913  10 
                     stream_211.add(char_literal490);
 20914   
 
 20915   
 
 20916  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5824);
 20917  8 
                     expression491=expression();
 20918   
 
 20919  10 
                     state._fsp--;
 20920   
 
 20921  8 
                     stream_expression.add(expression491.getTree());
 20922  2 
 
 20923  8 
                     char_literal492=(Token)match(input,210,FOLLOW_210_in_builtInCall5826);
 20924  8 
                     stream_210.add(char_literal492);
 20925   
 
 20926  2 
 
 20927  2 
                     // AST REWRITE
 20928   
                     // elements: expression, expression, STRAFTER
 20929   
                     // token labels:
 20930  2 
                     // rule labels: retval
 20931  2 
                     // token list labels:
 20932   
                     // rule list labels:
 20933   
                     // wildcard labels:
 20934  10 
                     retval.tree = root_0;
 20935  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20936   
 
 20937  10 
                     root_0 = (Object)adaptor.nil();
 20938   
                     // 598:50: -> ^( STRAFTER expression expression )
 20939  2 
                     {
 20940   
                         // com\\googlecode\\sparkleg\\Sparql.g:598:53: ^( STRAFTER expression expression )
 20941  2 
                         {
 20942  10 
                         Object root_1 = (Object)adaptor.nil();
 20943  8 
                         root_1 = (Object)adaptor.becomeRoot(
 20944   
                         stream_STRAFTER.nextNode()
 20945   
                         , root_1);
 20946   
 
 20947  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20948   
 
 20949  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20950   
 
 20951  8 
                         adaptor.addChild(root_0, root_1);
 20952  2 
                         }
 20953  2 
 
 20954   
                     }
 20955  2 
 
 20956   
 
 20957  8 
                     retval.tree = root_0;
 20958   
 
 20959   
                     }
 20960  10 
                     break;
 20961  2 
                 case 27 :
 20962   
                     // com\\googlecode\\sparkleg\\Sparql.g:599:7: YEAR '(' expression ')'
 20963   
                     {
 20964  8 
                     YEAR493=(Token)match(input,YEAR,FOLLOW_YEAR_in_builtInCall5844);
 20965  10 
                     stream_YEAR.add(YEAR493);
 20966   
 
 20967  2 
 
 20968  8 
                     char_literal494=(Token)match(input,209,FOLLOW_209_in_builtInCall5846);
 20969  8 
                     stream_209.add(char_literal494);
 20970   
 
 20971   
 
 20972  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5848);
 20973  10 
                     expression495=expression();
 20974   
 
 20975  8 
                     state._fsp--;
 20976  2 
 
 20977  8 
                     stream_expression.add(expression495.getTree());
 20978   
 
 20979  8 
                     char_literal496=(Token)match(input,210,FOLLOW_210_in_builtInCall5850);
 20980  10 
                     stream_210.add(char_literal496);
 20981  2 
 
 20982   
 
 20983   
                     // AST REWRITE
 20984  2 
                     // elements: YEAR, expression
 20985  2 
                     // token labels:
 20986   
                     // rule labels: retval
 20987   
                     // token list labels:
 20988  2 
                     // rule list labels:
 20989  2 
                     // wildcard labels:
 20990  8 
                     retval.tree = root_0;
 20991  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20992   
 
 20993  10 
                     root_0 = (Object)adaptor.nil();
 20994   
                     // 599:31: -> ^( YEAR expression )
 20995  2 
                     {
 20996  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:599:34: ^( YEAR expression )
 20997   
                         {
 20998  8 
                         Object root_1 = (Object)adaptor.nil();
 20999  8 
                         root_1 = (Object)adaptor.becomeRoot(
 21000   
                         stream_YEAR.nextNode()
 21001   
                         , root_1);
 21002   
 
 21003  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21004   
 
 21005  8 
                         adaptor.addChild(root_0, root_1);
 21006  2 
                         }
 21007  2 
 
 21008   
                     }
 21009  2 
 
 21010   
 
 21011  8 
                     retval.tree = root_0;
 21012   
 
 21013   
                     }
 21014  10 
                     break;
 21015  2 
                 case 28 :
 21016   
                     // com\\googlecode\\sparkleg\\Sparql.g:600:7: MONTH '(' expression ')'
 21017   
                     {
 21018  8 
                     MONTH497=(Token)match(input,MONTH,FOLLOW_MONTH_in_builtInCall5866);
 21019  10 
                     stream_MONTH.add(MONTH497);
 21020   
 
 21021  2 
 
 21022  8 
                     char_literal498=(Token)match(input,209,FOLLOW_209_in_builtInCall5868);
 21023  8 
                     stream_209.add(char_literal498);
 21024   
 
 21025   
 
 21026  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5870);
 21027  10 
                     expression499=expression();
 21028   
 
 21029  8 
                     state._fsp--;
 21030  2 
 
 21031  8 
                     stream_expression.add(expression499.getTree());
 21032   
 
 21033  8 
                     char_literal500=(Token)match(input,210,FOLLOW_210_in_builtInCall5872);
 21034  10 
                     stream_210.add(char_literal500);
 21035  2 
 
 21036   
 
 21037   
                     // AST REWRITE
 21038  2 
                     // elements: MONTH, expression
 21039  2 
                     // token labels:
 21040   
                     // rule labels: retval
 21041   
                     // token list labels:
 21042  2 
                     // rule list labels:
 21043  2 
                     // wildcard labels:
 21044  8 
                     retval.tree = root_0;
 21045  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21046   
 
 21047  10 
                     root_0 = (Object)adaptor.nil();
 21048   
                     // 600:32: -> ^( MONTH expression )
 21049  2 
                     {
 21050  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:600:35: ^( MONTH expression )
 21051   
                         {
 21052  8 
                         Object root_1 = (Object)adaptor.nil();
 21053  8 
                         root_1 = (Object)adaptor.becomeRoot(
 21054   
                         stream_MONTH.nextNode()
 21055   
                         , root_1);
 21056   
 
 21057  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21058   
 
 21059  8 
                         adaptor.addChild(root_0, root_1);
 21060  2 
                         }
 21061  2 
 
 21062   
                     }
 21063  2 
 
 21064   
 
 21065  8 
                     retval.tree = root_0;
 21066   
 
 21067   
                     }
 21068  10 
                     break;
 21069  2 
                 case 29 :
 21070   
                     // com\\googlecode\\sparkleg\\Sparql.g:601:7: DAY '(' expression ')'
 21071   
                     {
 21072  8 
                     DAY501=(Token)match(input,DAY,FOLLOW_DAY_in_builtInCall5888);
 21073  10 
                     stream_DAY.add(DAY501);
 21074   
 
 21075  2 
 
 21076  8 
                     char_literal502=(Token)match(input,209,FOLLOW_209_in_builtInCall5890);
 21077  8 
                     stream_209.add(char_literal502);
 21078   
 
 21079   
 
 21080  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5892);
 21081  10 
                     expression503=expression();
 21082   
 
 21083  8 
                     state._fsp--;
 21084  2 
 
 21085  8 
                     stream_expression.add(expression503.getTree());
 21086   
 
 21087  8 
                     char_literal504=(Token)match(input,210,FOLLOW_210_in_builtInCall5894);
 21088  10 
                     stream_210.add(char_literal504);
 21089  2 
 
 21090   
 
 21091   
                     // AST REWRITE
 21092  2 
                     // elements: DAY, expression
 21093  2 
                     // token labels:
 21094   
                     // rule labels: retval
 21095   
                     // token list labels:
 21096  2 
                     // rule list labels:
 21097  2 
                     // wildcard labels:
 21098  8 
                     retval.tree = root_0;
 21099  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21100   
 
 21101  10 
                     root_0 = (Object)adaptor.nil();
 21102   
                     // 601:30: -> ^( DAY expression )
 21103  2 
                     {
 21104  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:601:33: ^( DAY expression )
 21105   
                         {
 21106  8 
                         Object root_1 = (Object)adaptor.nil();
 21107  8 
                         root_1 = (Object)adaptor.becomeRoot(
 21108   
                         stream_DAY.nextNode()
 21109   
                         , root_1);
 21110   
 
 21111  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21112   
 
 21113  8 
                         adaptor.addChild(root_0, root_1);
 21114  2 
                         }
 21115  2 
 
 21116   
                     }
 21117  2 
 
 21118   
 
 21119  8 
                     retval.tree = root_0;
 21120   
 
 21121   
                     }
 21122  10 
                     break;
 21123  2 
                 case 30 :
 21124   
                     // com\\googlecode\\sparkleg\\Sparql.g:602:7: HOURS '(' expression ')'
 21125   
                     {
 21126  8 
                     HOURS505=(Token)match(input,HOURS,FOLLOW_HOURS_in_builtInCall5910);
 21127  10 
                     stream_HOURS.add(HOURS505);
 21128   
 
 21129  2 
 
 21130  8 
                     char_literal506=(Token)match(input,209,FOLLOW_209_in_builtInCall5912);
 21131  8 
                     stream_209.add(char_literal506);
 21132   
 
 21133   
 
 21134  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5914);
 21135  10 
                     expression507=expression();
 21136   
 
 21137  8 
                     state._fsp--;
 21138  2 
 
 21139  8 
                     stream_expression.add(expression507.getTree());
 21140   
 
 21141  8 
                     char_literal508=(Token)match(input,210,FOLLOW_210_in_builtInCall5916);
 21142  10 
                     stream_210.add(char_literal508);
 21143  2 
 
 21144   
 
 21145   
                     // AST REWRITE
 21146  2 
                     // elements: HOURS, expression
 21147  2 
                     // token labels:
 21148   
                     // rule labels: retval
 21149   
                     // token list labels:
 21150  2 
                     // rule list labels:
 21151  2 
                     // wildcard labels:
 21152  8 
                     retval.tree = root_0;
 21153  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21154   
 
 21155  10 
                     root_0 = (Object)adaptor.nil();
 21156   
                     // 602:32: -> ^( HOURS expression )
 21157  2 
                     {
 21158  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:602:35: ^( HOURS expression )
 21159   
                         {
 21160  8 
                         Object root_1 = (Object)adaptor.nil();
 21161  8 
                         root_1 = (Object)adaptor.becomeRoot(
 21162   
                         stream_HOURS.nextNode()
 21163   
                         , root_1);
 21164   
 
 21165  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21166   
 
 21167  8 
                         adaptor.addChild(root_0, root_1);
 21168  2 
                         }
 21169  2 
 
 21170   
                     }
 21171  2 
 
 21172   
 
 21173  8 
                     retval.tree = root_0;
 21174   
 
 21175   
                     }
 21176  10 
                     break;
 21177  2 
                 case 31 :
 21178   
                     // com\\googlecode\\sparkleg\\Sparql.g:603:7: MINUTES '(' expression ')'
 21179   
                     {
 21180  8 
                     MINUTES509=(Token)match(input,MINUTES,FOLLOW_MINUTES_in_builtInCall5932);
 21181  10 
                     stream_MINUTES.add(MINUTES509);
 21182   
 
 21183  2 
 
 21184  8 
                     char_literal510=(Token)match(input,209,FOLLOW_209_in_builtInCall5934);
 21185  8 
                     stream_209.add(char_literal510);
 21186   
 
 21187   
 
 21188  8 
                     pushFollow(FOLLOW_expression_in_builtInCall5936);
 21189  10 
                     expression511=expression();
 21190   
 
 21191  8 
                     state._fsp--;
 21192  2 
 
 21193  8 
                     stream_expression.add(expression511.getTree());
 21194   
 
 21195  8 
                     char_literal512=(Token)match(input,210,FOLLOW_210_in_builtInCall5938);
 21196  10 
                     stream_210.add(char_literal512);
 21197  2 
 
 21198   
 
 21199   
                     // AST REWRITE
 21200  2 
                     // elements: expression, MINUTES
 21201  2 
                     // token labels:
 21202   
                     // rule labels: retval
 21203  2 
                     // token list labels:
 21204   
                     // rule list labels:
 21205  2 
                     // wildcard labels:
 21206  8 
                     retval.tree = root_0;
 21207  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21208   
 
 21209  8 
                     root_0 = (Object)adaptor.nil();
 21210   
                     // 603:34: -> ^( MINUTES expression )
 21211   
                     {
 21212   
                         // com\\googlecode\\sparkleg\\Sparql.g:603:37: ^( MINUTES expression )
 21213   
                         {
 21214  10 
                         Object root_1 = (Object)adaptor.nil();
 21215  10 
                         root_1 = (Object)adaptor.becomeRoot(
 21216   
                         stream_MINUTES.nextNode()
 21217  2 
                         , root_1);
 21218   
 
 21219  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21220  2 
 
 21221  8 
                         adaptor.addChild(root_0, root_1);
 21222   
                         }
 21223   
 
 21224   
                     }
 21225   
 
 21226   
 
 21227  10 
                     retval.tree = root_0;
 21228   
 
 21229   
                     }
 21230  10 
                     break;
 21231   
                 case 32 :
 21232   
                     // com\\googlecode\\sparkleg\\Sparql.g:604:7: SECONDS '(' expression ')'
 21233   
                     {
 21234  12 
                     SECONDS513=(Token)match(input,SECONDS,FOLLOW_SECONDS_in_builtInCall5954);
 21235  12 
                     stream_SECONDS.add(SECONDS513);
 21236   
 
 21237   
 
 21238  12 
                     char_literal514=(Token)match(input,209,FOLLOW_209_in_builtInCall5956);
 21239  12 
                     stream_209.add(char_literal514);
 21240   
 
 21241   
 
 21242  12 
                     pushFollow(FOLLOW_expression_in_builtInCall5958);
 21243  12 
                     expression515=expression();
 21244   
 
 21245  12 
                     state._fsp--;
 21246   
 
 21247  12 
                     stream_expression.add(expression515.getTree());
 21248   
 
 21249  12 
                     char_literal516=(Token)match(input,210,FOLLOW_210_in_builtInCall5960);
 21250  12 
                     stream_210.add(char_literal516);
 21251   
 
 21252   
 
 21253   
                     // AST REWRITE
 21254   
                     // elements: SECONDS, expression
 21255   
                     // token labels:
 21256   
                     // rule labels: retval
 21257   
                     // token list labels:
 21258   
                     // rule list labels:
 21259   
                     // wildcard labels:
 21260  12 
                     retval.tree = root_0;
 21261  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21262   
 
 21263  12 
                     root_0 = (Object)adaptor.nil();
 21264   
                     // 604:34: -> ^( SECONDS expression )
 21265   
                     {
 21266   
                         // com\\googlecode\\sparkleg\\Sparql.g:604:37: ^( SECONDS expression )
 21267   
                         {
 21268  12 
                         Object root_1 = (Object)adaptor.nil();
 21269  12 
                         root_1 = (Object)adaptor.becomeRoot(
 21270   
                         stream_SECONDS.nextNode()
 21271   
                         , root_1);
 21272   
 
 21273  12 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21274   
 
 21275  12 
                         adaptor.addChild(root_0, root_1);
 21276   
                         }
 21277   
 
 21278   
                     }
 21279   
 
 21280   
 
 21281  12 
                     retval.tree = root_0;
 21282   
 
 21283   
                     }
 21284  12 
                     break;
 21285   
                 case 33 :
 21286   
                     // com\\googlecode\\sparkleg\\Sparql.g:605:7: TIMEZONE '(' expression ')'
 21287   
                     {
 21288  12 
                     TIMEZONE517=(Token)match(input,TIMEZONE,FOLLOW_TIMEZONE_in_builtInCall5976);
 21289  12 
                     stream_TIMEZONE.add(TIMEZONE517);
 21290   
 
 21291   
 
 21292  12 
                     char_literal518=(Token)match(input,209,FOLLOW_209_in_builtInCall5978);
 21293  12 
                     stream_209.add(char_literal518);
 21294   
 
 21295   
 
 21296  12 
                     pushFollow(FOLLOW_expression_in_builtInCall5980);
 21297  12 
                     expression519=expression();
 21298   
 
 21299  12 
                     state._fsp--;
 21300   
 
 21301  12 
                     stream_expression.add(expression519.getTree());
 21302   
 
 21303  12 
                     char_literal520=(Token)match(input,210,FOLLOW_210_in_builtInCall5982);
 21304  12 
                     stream_210.add(char_literal520);
 21305   
 
 21306   
 
 21307   
                     // AST REWRITE
 21308   
                     // elements: TIMEZONE, expression
 21309   
                     // token labels:
 21310   
                     // rule labels: retval
 21311   
                     // token list labels:
 21312   
                     // rule list labels:
 21313   
                     // wildcard labels:
 21314  12 
                     retval.tree = root_0;
 21315  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21316   
 
 21317  12 
                     root_0 = (Object)adaptor.nil();
 21318   
                     // 605:35: -> ^( TIMEZONE expression )
 21319   
                     {
 21320   
                         // com\\googlecode\\sparkleg\\Sparql.g:605:38: ^( TIMEZONE expression )
 21321   
                         {
 21322  12 
                         Object root_1 = (Object)adaptor.nil();
 21323  12 
                         root_1 = (Object)adaptor.becomeRoot(
 21324   
                         stream_TIMEZONE.nextNode()
 21325   
                         , root_1);
 21326   
 
 21327  12 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21328   
 
 21329  12 
                         adaptor.addChild(root_0, root_1);
 21330   
                         }
 21331   
 
 21332   
                     }
 21333   
 
 21334   
 
 21335  12 
                     retval.tree = root_0;
 21336   
 
 21337   
                     }
 21338  12 
                     break;
 21339   
                 case 34 :
 21340   
                     // com\\googlecode\\sparkleg\\Sparql.g:606:7: TZ '(' expression ')'
 21341   
                     {
 21342  12 
                     TZ521=(Token)match(input,TZ,FOLLOW_TZ_in_builtInCall5998);
 21343  12 
                     stream_TZ.add(TZ521);
 21344   
 
 21345   
 
 21346  12 
                     char_literal522=(Token)match(input,209,FOLLOW_209_in_builtInCall6000);
 21347  12 
                     stream_209.add(char_literal522);
 21348   
 
 21349   
 
 21350  12 
                     pushFollow(FOLLOW_expression_in_builtInCall6002);
 21351  12 
                     expression523=expression();
 21352   
 
 21353  12 
                     state._fsp--;
 21354   
 
 21355  12 
                     stream_expression.add(expression523.getTree());
 21356   
 
 21357  12 
                     char_literal524=(Token)match(input,210,FOLLOW_210_in_builtInCall6004);
 21358  12 
                     stream_210.add(char_literal524);
 21359   
 
 21360   
 
 21361   
                     // AST REWRITE
 21362   
                     // elements: expression, TZ
 21363   
                     // token labels:
 21364   
                     // rule labels: retval
 21365   
                     // token list labels:
 21366   
                     // rule list labels:
 21367   
                     // wildcard labels:
 21368  12 
                     retval.tree = root_0;
 21369  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21370   
 
 21371  12 
                     root_0 = (Object)adaptor.nil();
 21372   
                     // 606:29: -> ^( TZ expression )
 21373   
                     {
 21374   
                         // com\\googlecode\\sparkleg\\Sparql.g:606:32: ^( TZ expression )
 21375   
                         {
 21376  12 
                         Object root_1 = (Object)adaptor.nil();
 21377  12 
                         root_1 = (Object)adaptor.becomeRoot(
 21378   
                         stream_TZ.nextNode()
 21379   
                         , root_1);
 21380   
 
 21381  12 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21382   
 
 21383  12 
                         adaptor.addChild(root_0, root_1);
 21384   
                         }
 21385   
 
 21386   
                     }
 21387   
 
 21388   
 
 21389  12 
                     retval.tree = root_0;
 21390   
 
 21391   
                     }
 21392  12 
                     break;
 21393   
                 case 35 :
 21394   
                     // com\\googlecode\\sparkleg\\Sparql.g:607:7: NOW nil
 21395   
                     {
 21396  12 
                     NOW525=(Token)match(input,NOW,FOLLOW_NOW_in_builtInCall6020);
 21397  12 
                     stream_NOW.add(NOW525);
 21398   
 
 21399   
 
 21400  12 
                     pushFollow(FOLLOW_nil_in_builtInCall6022);
 21401  12 
                     nil526=nil();
 21402   
 
 21403  8 
                     state._fsp--;
 21404  4 
 
 21405  12 
                     stream_nil.add(nil526.getTree());
 21406   
 
 21407  4 
                     // AST REWRITE
 21408   
                     // elements: NOW
 21409  4 
                     // token labels:
 21410   
                     // rule labels: retval
 21411  4 
                     // token list labels:
 21412  4 
                     // rule list labels:
 21413   
                     // wildcard labels:
 21414  8 
                     retval.tree = root_0;
 21415  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21416   
 
 21417  8 
                     root_0 = (Object)adaptor.nil();
 21418   
                     // 607:15: -> NOW
 21419   
                     {
 21420  8 
                         adaptor.addChild(root_0,
 21421   
                         stream_NOW.nextNode()
 21422  4 
                         );
 21423  4 
 
 21424   
                     }
 21425  4 
 
 21426   
 
 21427  8 
                     retval.tree = root_0;
 21428   
 
 21429   
                     }
 21430  12 
                     break;
 21431  4 
                 case 36 :
 21432   
                     // com\\googlecode\\sparkleg\\Sparql.g:608:7: MD5 '(' expression ')'
 21433   
                     {
 21434  16 
                     MD5527=(Token)match(input,MD5,FOLLOW_MD5_in_builtInCall6034);
 21435  20 
                     stream_MD5.add(MD5527);
 21436   
 
 21437  4 
 
 21438  16 
                     char_literal528=(Token)match(input,209,FOLLOW_209_in_builtInCall6036);
 21439  16 
                     stream_209.add(char_literal528);
 21440   
 
 21441   
 
 21442  16 
                     pushFollow(FOLLOW_expression_in_builtInCall6038);
 21443  20 
                     expression529=expression();
 21444   
 
 21445  16 
                     state._fsp--;
 21446  4 
 
 21447  16 
                     stream_expression.add(expression529.getTree());
 21448   
 
 21449  16 
                     char_literal530=(Token)match(input,210,FOLLOW_210_in_builtInCall6040);
 21450  20 
                     stream_210.add(char_literal530);
 21451  4 
 
 21452   
 
 21453   
                     // AST REWRITE
 21454  4 
                     // elements: expression, MD5
 21455  4 
                     // token labels:
 21456   
                     // rule labels: retval
 21457   
                     // token list labels:
 21458  4 
                     // rule list labels:
 21459  4 
                     // wildcard labels:
 21460  16 
                     retval.tree = root_0;
 21461  20 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21462   
 
 21463  20 
                     root_0 = (Object)adaptor.nil();
 21464   
                     // 608:30: -> ^( MD5 expression )
 21465  4 
                     {
 21466  4 
                         // com\\googlecode\\sparkleg\\Sparql.g:608:33: ^( MD5 expression )
 21467   
                         {
 21468  16 
                         Object root_1 = (Object)adaptor.nil();
 21469  16 
                         root_1 = (Object)adaptor.becomeRoot(
 21470   
                         stream_MD5.nextNode()
 21471   
                         , root_1);
 21472   
 
 21473  16 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21474   
 
 21475  16 
                         adaptor.addChild(root_0, root_1);
 21476  4 
                         }
 21477  4 
 
 21478   
                     }
 21479  4 
 
 21480   
 
 21481  16 
                     retval.tree = root_0;
 21482   
 
 21483   
                     }
 21484  20 
                     break;
 21485  4 
                 case 37 :
 21486   
                     // com\\googlecode\\sparkleg\\Sparql.g:609:7: SHA1 '(' expression ')'
 21487   
                     {
 21488  16 
                     SHA1531=(Token)match(input,SHA1,FOLLOW_SHA1_in_builtInCall6056);
 21489  20 
                     stream_SHA1.add(SHA1531);
 21490   
 
 21491  4 
 
 21492  16 
                     char_literal532=(Token)match(input,209,FOLLOW_209_in_builtInCall6058);
 21493  16 
                     stream_209.add(char_literal532);
 21494   
 
 21495   
 
 21496  16 
                     pushFollow(FOLLOW_expression_in_builtInCall6060);
 21497  20 
                     expression533=expression();
 21498   
 
 21499  16 
                     state._fsp--;
 21500  4 
 
 21501  16 
                     stream_expression.add(expression533.getTree());
 21502   
 
 21503  16 
                     char_literal534=(Token)match(input,210,FOLLOW_210_in_builtInCall6062);
 21504  28 
                     stream_210.add(char_literal534);
 21505  12 
 
 21506   
 
 21507   
                     // AST REWRITE
 21508  12 
                     // elements: expression, SHA1
 21509  12 
                     // token labels:
 21510   
                     // rule labels: retval
 21511  12 
                     // token list labels:
 21512   
                     // rule list labels:
 21513  12 
                     // wildcard labels:
 21514  16 
                     retval.tree = root_0;
 21515  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21516   
 
 21517  16 
                     root_0 = (Object)adaptor.nil();
 21518   
                     // 609:31: -> ^( SHA1 expression )
 21519   
                     {
 21520   
                         // com\\googlecode\\sparkleg\\Sparql.g:609:34: ^( SHA1 expression )
 21521   
                         {
 21522  28 
                         Object root_1 = (Object)adaptor.nil();
 21523  28 
                         root_1 = (Object)adaptor.becomeRoot(
 21524   
                         stream_SHA1.nextNode()
 21525  12 
                         , root_1);
 21526   
 
 21527  16 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21528   
 
 21529  16 
                         adaptor.addChild(root_0, root_1);
 21530  12 
                         }
 21531  12 
 
 21532   
                     }
 21533   
 
 21534   
 
 21535  28 
                     retval.tree = root_0;
 21536   
 
 21537  12 
                     }
 21538  16 
                     break;
 21539   
                 case 38 :
 21540   
                     // com\\googlecode\\sparkleg\\Sparql.g:610:7: SHA256 '(' expression ')'
 21541   
                     {
 21542  16 
                     SHA256535=(Token)match(input,SHA256,FOLLOW_SHA256_in_builtInCall6078);
 21543  28 
                     stream_SHA256.add(SHA256535);
 21544   
 
 21545   
 
 21546  28 
                     char_literal536=(Token)match(input,209,FOLLOW_209_in_builtInCall6080);
 21547  16 
                     stream_209.add(char_literal536);
 21548   
 
 21549   
 
 21550  22 
                     pushFollow(FOLLOW_expression_in_builtInCall6082);
 21551  22 
                     expression537=expression();
 21552   
 
 21553  16 
                     state._fsp--;
 21554  6 
 
 21555  22 
                     stream_expression.add(expression537.getTree());
 21556   
 
 21557  16 
                     char_literal538=(Token)match(input,210,FOLLOW_210_in_builtInCall6084);
 21558  22 
                     stream_210.add(char_literal538);
 21559  6 
 
 21560   
 
 21561  6 
                     // AST REWRITE
 21562   
                     // elements: SHA256, expression
 21563  6 
                     // token labels:
 21564   
                     // rule labels: retval
 21565  6 
                     // token list labels:
 21566  6 
                     // rule list labels:
 21567   
                     // wildcard labels:
 21568  16 
                     retval.tree = root_0;
 21569  22 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21570  6 
 
 21571  16 
                     root_0 = (Object)adaptor.nil();
 21572  6 
                     // 610:33: -> ^( SHA256 expression )
 21573   
                     {
 21574  6 
                         // com\\googlecode\\sparkleg\\Sparql.g:610:36: ^( SHA256 expression )
 21575   
                         {
 21576  22 
                         Object root_1 = (Object)adaptor.nil();
 21577  22 
                         root_1 = (Object)adaptor.becomeRoot(
 21578   
                         stream_SHA256.nextNode()
 21579   
                         , root_1);
 21580  6 
 
 21581  22 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21582   
 
 21583  22 
                         adaptor.addChild(root_0, root_1);
 21584   
                         }
 21585  6 
 
 21586   
                     }
 21587  6 
 
 21588  6 
 
 21589  16 
                     retval.tree = root_0;
 21590   
 
 21591   
                     }
 21592  16 
                     break;
 21593   
                 case 39 :
 21594   
                     // com\\googlecode\\sparkleg\\Sparql.g:611:7: SHA384 '(' expression ')'
 21595   
                     {
 21596  16 
                     SHA384539=(Token)match(input,SHA384,FOLLOW_SHA384_in_builtInCall6100);
 21597  16 
                     stream_SHA384.add(SHA384539);
 21598  6 
 
 21599  6 
 
 21600  22 
                     char_literal540=(Token)match(input,209,FOLLOW_209_in_builtInCall6102);
 21601  22 
                     stream_209.add(char_literal540);
 21602  6 
 
 21603   
 
 21604  22 
                     pushFollow(FOLLOW_expression_in_builtInCall6104);
 21605  16 
                     expression541=expression();
 21606   
 
 21607  16 
                     state._fsp--;
 21608   
 
 21609  22 
                     stream_expression.add(expression541.getTree());
 21610  6 
 
 21611  16 
                     char_literal542=(Token)match(input,210,FOLLOW_210_in_builtInCall6106);
 21612  16 
                     stream_210.add(char_literal542);
 21613   
 
 21614  6 
 
 21615   
                     // AST REWRITE
 21616  6 
                     // elements: expression, SHA384
 21617   
                     // token labels:
 21618  6 
                     // rule labels: retval
 21619   
                     // token list labels:
 21620  6 
                     // rule list labels:
 21621   
                     // wildcard labels:
 21622  16 
                     retval.tree = root_0;
 21623  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21624   
 
 21625  16 
                     root_0 = (Object)adaptor.nil();
 21626  6 
                     // 611:33: -> ^( SHA384 expression )
 21627   
                     {
 21628   
                         // com\\googlecode\\sparkleg\\Sparql.g:611:36: ^( SHA384 expression )
 21629  6 
                         {
 21630  16 
                         Object root_1 = (Object)adaptor.nil();
 21631  16 
                         root_1 = (Object)adaptor.becomeRoot(
 21632   
                         stream_SHA384.nextNode()
 21633  6 
                         , root_1);
 21634  6 
 
 21635  16 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21636   
 
 21637  22 
                         adaptor.addChild(root_0, root_1);
 21638  6 
                         }
 21639   
 
 21640   
                     }
 21641  6 
 
 21642  6 
 
 21643  16 
                     retval.tree = root_0;
 21644  6 
 
 21645   
                     }
 21646  22 
                     break;
 21647   
                 case 40 :
 21648  6 
                     // com\\googlecode\\sparkleg\\Sparql.g:612:7: SHA512 '(' expression ')'
 21649  6 
                     {
 21650  16 
                     SHA512543=(Token)match(input,SHA512,FOLLOW_SHA512_in_builtInCall6122);
 21651  16 
                     stream_SHA512.add(SHA512543);
 21652  6 
 
 21653  6 
 
 21654  16 
                     char_literal544=(Token)match(input,209,FOLLOW_209_in_builtInCall6124);
 21655  22 
                     stream_209.add(char_literal544);
 21656   
 
 21657  6 
 
 21658  16 
                     pushFollow(FOLLOW_expression_in_builtInCall6126);
 21659  22 
                     expression545=expression();
 21660  6 
 
 21661  16 
                     state._fsp--;
 21662   
 
 21663  16 
                     stream_expression.add(expression545.getTree());
 21664   
 
 21665  16 
                     char_literal546=(Token)match(input,210,FOLLOW_210_in_builtInCall6128);
 21666  16 
                     stream_210.add(char_literal546);
 21667   
 
 21668   
 
 21669   
                     // AST REWRITE
 21670  6 
                     // elements: expression, SHA512
 21671  6 
                     // token labels:
 21672   
                     // rule labels: retval
 21673  6 
                     // token list labels:
 21674   
                     // rule list labels:
 21675   
                     // wildcard labels:
 21676  16 
                     retval.tree = root_0;
 21677  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21678  6 
 
 21679  22 
                     root_0 = (Object)adaptor.nil();
 21680   
                     // 612:33: -> ^( SHA512 expression )
 21681   
                     {
 21682   
                         // com\\googlecode\\sparkleg\\Sparql.g:612:36: ^( SHA512 expression )
 21683  6 
                         {
 21684  16 
                         Object root_1 = (Object)adaptor.nil();
 21685  22 
                         root_1 = (Object)adaptor.becomeRoot(
 21686   
                         stream_SHA512.nextNode()
 21687  6 
                         , root_1);
 21688   
 
 21689  16 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21690   
 
 21691  16 
                         adaptor.addChild(root_0, root_1);
 21692   
                         }
 21693  6 
 
 21694   
                     }
 21695   
 
 21696  6 
 
 21697  16 
                     retval.tree = root_0;
 21698   
 
 21699   
                     }
 21700  22 
                     break;
 21701  6 
                 case 41 :
 21702   
                     // com\\googlecode\\sparkleg\\Sparql.g:613:7: COALESCE expressionList
 21703   
                     {
 21704  54 
                     COALESCE547=(Token)match(input,COALESCE,FOLLOW_COALESCE_in_builtInCall6144);
 21705  54 
                     stream_COALESCE.add(COALESCE547);
 21706   
 
 21707   
 
 21708  54 
                     pushFollow(FOLLOW_expressionList_in_builtInCall6146);
 21709  54 
                     expressionList548=expressionList();
 21710   
 
 21711  54 
                     state._fsp--;
 21712   
 
 21713  54 
                     stream_expressionList.add(expressionList548.getTree());
 21714   
 
 21715  6 
                     // AST REWRITE
 21716  6 
                     // elements: COALESCE, expressionList
 21717   
                     // token labels:
 21718   
                     // rule labels: retval
 21719  6 
                     // token list labels:
 21720  6 
                     // rule list labels:
 21721   
                     // wildcard labels:
 21722  54 
                     retval.tree = root_0;
 21723  48 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21724  6 
 
 21725  48 
                     root_0 = (Object)adaptor.nil();
 21726  6 
                     // 613:31: -> ^( COALESCE expressionList )
 21727  6 
                     {
 21728   
                         // com\\googlecode\\sparkleg\\Sparql.g:613:34: ^( COALESCE expressionList )
 21729   
                         {
 21730  48 
                         Object root_1 = (Object)adaptor.nil();
 21731  48 
                         root_1 = (Object)adaptor.becomeRoot(
 21732   
                         stream_COALESCE.nextNode()
 21733   
                         , root_1);
 21734   
 
 21735  48 
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 21736   
 
 21737  54 
                         adaptor.addChild(root_0, root_1);
 21738  6 
                         }
 21739   
 
 21740  6 
                     }
 21741   
 
 21742   
 
 21743  48 
                     retval.tree = root_0;
 21744   
 
 21745  6 
                     }
 21746  54 
                     break;
 21747   
                 case 42 :
 21748   
                     // com\\googlecode\\sparkleg\\Sparql.g:614:7: IF '(' e1= expression ',' e2= expression ',' e3= expression ')'
 21749   
                     {
 21750  30 
                     IF549=(Token)match(input,IF,FOLLOW_IF_in_builtInCall6162);
 21751  24 
                     stream_IF.add(IF549);
 21752  6 
 
 21753   
 
 21754  30 
                     char_literal550=(Token)match(input,209,FOLLOW_209_in_builtInCall6164);
 21755  24 
                     stream_209.add(char_literal550);
 21756   
 
 21757   
 
 21758  24 
                     pushFollow(FOLLOW_expression_in_builtInCall6168);
 21759  24 
                     e1=expression();
 21760  6 
 
 21761  24 
                     state._fsp--;
 21762   
 
 21763  30 
                     stream_expression.add(e1.getTree());
 21764   
 
 21765  24 
                     char_literal551=(Token)match(input,211,FOLLOW_211_in_builtInCall6170);
 21766  24 
                     stream_211.add(char_literal551);
 21767  30 
 
 21768  30 
 
 21769  24 
                     pushFollow(FOLLOW_expression_in_builtInCall6174);
 21770  24 
                     e2=expression();
 21771  30 
 
 21772  54 
                     state._fsp--;
 21773   
 
 21774  24 
                     stream_expression.add(e2.getTree());
 21775  30 
 
 21776  54 
                     char_literal552=(Token)match(input,211,FOLLOW_211_in_builtInCall6176);
 21777  24 
                     stream_211.add(char_literal552);
 21778  30 
 
 21779   
 
 21780  54 
                     pushFollow(FOLLOW_expression_in_builtInCall6180);
 21781  24 
                     e3=expression();
 21782  30 
 
 21783  54 
                     state._fsp--;
 21784   
 
 21785  24 
                     stream_expression.add(e3.getTree());
 21786  30 
 
 21787  54 
                     char_literal553=(Token)match(input,210,FOLLOW_210_in_builtInCall6182);
 21788  24 
                     stream_210.add(char_literal553);
 21789  30 
 
 21790   
 
 21791  30 
                     // AST REWRITE
 21792   
                     // elements: e3, e2, e1, IF
 21793  30 
                     // token labels:
 21794  30 
                     // rule labels: e3, retval, e1, e2
 21795   
                     // token list labels:
 21796   
                     // rule list labels:
 21797   
                     // wildcard labels:
 21798  24 
                     retval.tree = root_0;
 21799  24 
                     RewriteRuleSubtreeStream stream_e3=new RewriteRuleSubtreeStream(adaptor,"rule e3",e3!=null?e3.tree:null);
 21800  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21801  24 
                     RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.tree:null);
 21802  24 
                     RewriteRuleSubtreeStream stream_e2=new RewriteRuleSubtreeStream(adaptor,"rule e2",e2!=null?e2.tree:null);
 21803   
 
 21804  54 
                     root_0 = (Object)adaptor.nil();
 21805  30 
                     // 614:68: -> ^( IF $e1 $e2 $e3)
 21806   
                     {
 21807  30 
                         // com\\googlecode\\sparkleg\\Sparql.g:614:71: ^( IF $e1 $e2 $e3)
 21808   
                         {
 21809  24 
                         Object root_1 = (Object)adaptor.nil();
 21810  24 
                         root_1 = (Object)adaptor.becomeRoot(
 21811   
                         stream_IF.nextNode()
 21812  30 
                         , root_1);
 21813  30 
 
 21814  24 
                         adaptor.addChild(root_1, stream_e1.nextTree());
 21815   
 
 21816  24 
                         adaptor.addChild(root_1, stream_e2.nextTree());
 21817  30 
 
 21818  24 
                         adaptor.addChild(root_1, stream_e3.nextTree());
 21819  30 
 
 21820  24 
                         adaptor.addChild(root_0, root_1);
 21821  30 
                         }
 21822   
 
 21823   
                     }
 21824   
 
 21825   
 
 21826  24 
                     retval.tree = root_0;
 21827  30 
 
 21828   
                     }
 21829  24 
                     break;
 21830  30 
                 case 43 :
 21831   
                     // com\\googlecode\\sparkleg\\Sparql.g:615:7: STRLANG '(' expression ',' expression ')'
 21832   
                     {
 21833  24 
                     STRLANG554=(Token)match(input,STRLANG,FOLLOW_STRLANG_in_builtInCall6205);
 21834  32 
                     stream_STRLANG.add(STRLANG554);
 21835  8 
 
 21836   
 
 21837  24 
                     char_literal555=(Token)match(input,209,FOLLOW_209_in_builtInCall6207);
 21838  32 
                     stream_209.add(char_literal555);
 21839  8 
 
 21840   
 
 21841  24 
                     pushFollow(FOLLOW_expression_in_builtInCall6209);
 21842  32 
                     expression556=expression();
 21843  8 
 
 21844  24 
                     state._fsp--;
 21845  8 
 
 21846  24 
                     stream_expression.add(expression556.getTree());
 21847  8 
 
 21848  24 
                     char_literal557=(Token)match(input,211,FOLLOW_211_in_builtInCall6211);
 21849  32 
                     stream_211.add(char_literal557);
 21850  8 
 
 21851   
 
 21852  24 
                     pushFollow(FOLLOW_expression_in_builtInCall6213);
 21853  24 
                     expression558=expression();
 21854   
 
 21855  24 
                     state._fsp--;
 21856   
 
 21857  24 
                     stream_expression.add(expression558.getTree());
 21858   
 
 21859  24 
                     char_literal559=(Token)match(input,210,FOLLOW_210_in_builtInCall6215);
 21860  32 
                     stream_210.add(char_literal559);
 21861  8 
 
 21862   
 
 21863  8 
                     // AST REWRITE
 21864   
                     // elements: STRLANG, expression, expression
 21865   
                     // token labels:
 21866   
                     // rule labels: retval
 21867   
                     // token list labels:
 21868  8 
                     // rule list labels:
 21869  8 
                     // wildcard labels:
 21870  24 
                     retval.tree = root_0;
 21871  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21872   
 
 21873  32 
                     root_0 = (Object)adaptor.nil();
 21874   
                     // 615:49: -> ^( STRLANG expression expression )
 21875  8 
                     {
 21876   
                         // com\\googlecode\\sparkleg\\Sparql.g:615:52: ^( STRLANG expression expression )
 21877   
                         {
 21878  24 
                         Object root_1 = (Object)adaptor.nil();
 21879  24 
                         root_1 = (Object)adaptor.becomeRoot(
 21880   
                         stream_STRLANG.nextNode()
 21881  8 
                         , root_1);
 21882   
 
 21883  24 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21884  8 
 
 21885  24 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21886   
 
 21887  24 
                         adaptor.addChild(root_0, root_1);
 21888  2 
                         }
 21889  2 
 
 21890   
                     }
 21891   
 
 21892  2 
 
 21893  26 
                     retval.tree = root_0;
 21894   
 
 21895   
                     }
 21896  26 
                     break;
 21897  2 
                 case 44 :
 21898   
                     // com\\googlecode\\sparkleg\\Sparql.g:616:7: STRDT '(' expression ',' expression ')'
 21899  2 
                     {
 21900  24 
                     STRDT560=(Token)match(input,STRDT,FOLLOW_STRDT_in_builtInCall6233);
 21901  26 
                     stream_STRDT.add(STRDT560);
 21902   
 
 21903  2 
 
 21904  26 
                     char_literal561=(Token)match(input,209,FOLLOW_209_in_builtInCall6235);
 21905  24 
                     stream_209.add(char_literal561);
 21906   
 
 21907   
 
 21908  24 
                     pushFollow(FOLLOW_expression_in_builtInCall6237);
 21909  24 
                     expression562=expression();
 21910   
 
 21911  24 
                     state._fsp--;
 21912   
 
 21913  24 
                     stream_expression.add(expression562.getTree());
 21914  2 
 
 21915  26 
                     char_literal563=(Token)match(input,211,FOLLOW_211_in_builtInCall6239);
 21916  24 
                     stream_211.add(char_literal563);
 21917  2 
 
 21918   
 
 21919  24 
                     pushFollow(FOLLOW_expression_in_builtInCall6241);
 21920  24 
                     expression564=expression();
 21921   
 
 21922  26 
                     state._fsp--;
 21923  2 
 
 21924  24 
                     stream_expression.add(expression564.getTree());
 21925   
 
 21926  24 
                     char_literal565=(Token)match(input,210,FOLLOW_210_in_builtInCall6243);
 21927  26 
                     stream_210.add(char_literal565);
 21928   
 
 21929  2 
 
 21930   
                     // AST REWRITE
 21931   
                     // elements: STRDT, expression, expression
 21932   
                     // token labels:
 21933   
                     // rule labels: retval
 21934   
                     // token list labels:
 21935  2 
                     // rule list labels:
 21936   
                     // wildcard labels:
 21937  24 
                     retval.tree = root_0;
 21938  26 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21939   
 
 21940  24 
                     root_0 = (Object)adaptor.nil();
 21941   
                     // 616:47: -> ^( STRDT expression expression )
 21942  8 
                     {
 21943  8 
                         // com\\googlecode\\sparkleg\\Sparql.g:616:50: ^( STRDT expression expression )
 21944   
                         {
 21945  24 
                         Object root_1 = (Object)adaptor.nil();
 21946  32 
                         root_1 = (Object)adaptor.becomeRoot(
 21947  8 
                         stream_STRDT.nextNode()
 21948   
                         , root_1);
 21949   
 
 21950  32 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21951  8 
 
 21952  24 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21953  8 
 
 21954  24 
                         adaptor.addChild(root_0, root_1);
 21955  8 
                         }
 21956   
 
 21957  8 
                     }
 21958  8 
 
 21959   
 
 21960  24 
                     retval.tree = root_0;
 21961   
 
 21962   
                     }
 21963  24 
                     break;
 21964   
                 case 45 :
 21965   
                     // com\\googlecode\\sparkleg\\Sparql.g:617:7: SAMETERM '(' expression ',' expression ')'
 21966   
                     {
 21967  120 
                     SAMETERM566=(Token)match(input,SAMETERM,FOLLOW_SAMETERM_in_builtInCall6261);
 21968  128 
                     stream_SAMETERM.add(SAMETERM566);
 21969  8 
 
 21970   
 
 21971  128 
                     char_literal567=(Token)match(input,209,FOLLOW_209_in_builtInCall6263);
 21972  120 
                     stream_209.add(char_literal567);
 21973   
 
 21974   
 
 21975  120 
                     pushFollow(FOLLOW_expression_in_builtInCall6265);
 21976  128 
                     expression568=expression();
 21977  8 
 
 21978  120 
                     state._fsp--;
 21979   
 
 21980  120 
                     stream_expression.add(expression568.getTree());
 21981  8 
 
 21982  120 
                     char_literal569=(Token)match(input,211,FOLLOW_211_in_builtInCall6267);
 21983  128 
                     stream_211.add(char_literal569);
 21984   
 
 21985   
 
 21986  120 
                     pushFollow(FOLLOW_expression_in_builtInCall6269);
 21987  120 
                     expression570=expression();
 21988   
 
 21989  128 
                     state._fsp--;
 21990   
 
 21991  120 
                     stream_expression.add(expression570.getTree());
 21992  8 
 
 21993  120 
                     char_literal571=(Token)match(input,210,FOLLOW_210_in_builtInCall6271);
 21994  120 
                     stream_210.add(char_literal571);
 21995   
 
 21996  8 
 
 21997  8 
                     // AST REWRITE
 21998   
                     // elements: expression, expression, SAMETERM
 21999   
                     // token labels:
 22000  8 
                     // rule labels: retval
 22001  8 
                     // token list labels:
 22002   
                     // rule list labels:
 22003   
                     // wildcard labels:
 22004  128 
                     retval.tree = root_0;
 22005  128 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22006   
 
 22007  128 
                     root_0 = (Object)adaptor.nil();
 22008   
                     // 617:50: -> ^( SAMETERM expression expression )
 22009  8 
                     {
 22010   
                         // com\\googlecode\\sparkleg\\Sparql.g:617:53: ^( SAMETERM expression expression )
 22011  8 
                         {
 22012  128 
                         Object root_1 = (Object)adaptor.nil();
 22013  120 
                         root_1 = (Object)adaptor.becomeRoot(
 22014   
                         stream_SAMETERM.nextNode()
 22015   
                         , root_1);
 22016   
 
 22017  120 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22018   
 
 22019  120 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22020   
 
 22021  120 
                         adaptor.addChild(root_0, root_1);
 22022  8 
                         }
 22023  8 
 
 22024   
                     }
 22025  8 
 
 22026   
 
 22027  120 
                     retval.tree = root_0;
 22028   
 
 22029   
                     }
 22030  128 
                     break;
 22031  8 
                 case 46 :
 22032   
                     // com\\googlecode\\sparkleg\\Sparql.g:618:7: ISIRI '(' expression ')'
 22033   
                     {
 22034  32 
                     ISIRI572=(Token)match(input,ISIRI,FOLLOW_ISIRI_in_builtInCall6289);
 22035  40 
                     stream_ISIRI.add(ISIRI572);
 22036   
 
 22037  8 
 
 22038  32 
                     char_literal573=(Token)match(input,209,FOLLOW_209_in_builtInCall6291);
 22039  32 
                     stream_209.add(char_literal573);
 22040   
 
 22041   
 
 22042  32 
                     pushFollow(FOLLOW_expression_in_builtInCall6293);
 22043  40 
                     expression574=expression();
 22044   
 
 22045  32 
                     state._fsp--;
 22046  8 
 
 22047  32 
                     stream_expression.add(expression574.getTree());
 22048   
 
 22049  32 
                     char_literal575=(Token)match(input,210,FOLLOW_210_in_builtInCall6295);
 22050  36 
                     stream_210.add(char_literal575);
 22051  4 
 
 22052   
 
 22053   
                     // AST REWRITE
 22054  4 
                     // elements: expression, ISIRI
 22055  4 
                     // token labels:
 22056   
                     // rule labels: retval
 22057   
                     // token list labels:
 22058  4 
                     // rule list labels:
 22059  4 
                     // wildcard labels:
 22060  32 
                     retval.tree = root_0;
 22061  36 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22062   
 
 22063  36 
                     root_0 = (Object)adaptor.nil();
 22064   
                     // 618:32: -> ^( ISIRI expression )
 22065  4 
                     {
 22066  4 
                         // com\\googlecode\\sparkleg\\Sparql.g:618:35: ^( ISIRI expression )
 22067   
                         {
 22068  32 
                         Object root_1 = (Object)adaptor.nil();
 22069  32 
                         root_1 = (Object)adaptor.becomeRoot(
 22070   
                         stream_ISIRI.nextNode()
 22071   
                         , root_1);
 22072   
 
 22073  32 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22074   
 
 22075  32 
                         adaptor.addChild(root_0, root_1);
 22076  4 
                         }
 22077  4 
 
 22078   
                     }
 22079  4 
 
 22080   
 
 22081  32 
                     retval.tree = root_0;
 22082   
 
 22083   
                     }
 22084  36 
                     break;
 22085  4 
                 case 47 :
 22086   
                     // com\\googlecode\\sparkleg\\Sparql.g:619:7: ISURI '(' expression ')'
 22087   
                     {
 22088  8 
                     ISURI576=(Token)match(input,ISURI,FOLLOW_ISURI_in_builtInCall6311);
 22089  12 
                     stream_ISURI.add(ISURI576);
 22090   
 
 22091  4 
 
 22092  8 
                     char_literal577=(Token)match(input,209,FOLLOW_209_in_builtInCall6313);
 22093  8 
                     stream_209.add(char_literal577);
 22094   
 
 22095   
 
 22096  8 
                     pushFollow(FOLLOW_expression_in_builtInCall6315);
 22097  12 
                     expression578=expression();
 22098   
 
 22099  8 
                     state._fsp--;
 22100  4 
 
 22101  8 
                     stream_expression.add(expression578.getTree());
 22102   
 
 22103  8 
                     char_literal579=(Token)match(input,210,FOLLOW_210_in_builtInCall6317);
 22104  50 
                     stream_210.add(char_literal579);
 22105  42 
 
 22106   
 
 22107  42 
                     // AST REWRITE
 22108   
                     // elements: expression, ISURI
 22109  42 
                     // token labels:
 22110   
                     // rule labels: retval
 22111   
                     // token list labels:
 22112   
                     // rule list labels:
 22113   
                     // wildcard labels:
 22114  8 
                     retval.tree = root_0;
 22115  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22116   
 
 22117  8 
                     root_0 = (Object)adaptor.nil();
 22118  42 
                     // 619:32: -> ^( ISURI expression )
 22119  42 
                     {
 22120   
                         // com\\googlecode\\sparkleg\\Sparql.g:619:35: ^( ISURI expression )
 22121  42 
                         {
 22122  8 
                         Object root_1 = (Object)adaptor.nil();
 22123  8 
                         root_1 = (Object)adaptor.becomeRoot(
 22124  42 
                         stream_ISURI.nextNode()
 22125   
                         , root_1);
 22126   
 
 22127  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22128   
 
 22129  50 
                         adaptor.addChild(root_0, root_1);
 22130   
                         }
 22131   
 
 22132  42 
                     }
 22133   
 
 22134   
 
 22135  8 
                     retval.tree = root_0;
 22136  20 
 
 22137  20 
                     }
 22138  8 
                     break;
 22139  20 
                 case 48 :
 22140   
                     // com\\googlecode\\sparkleg\\Sparql.g:620:7: ISBLANK '(' expression ')'
 22141  20 
                     {
 22142  32 
                     ISBLANK580=(Token)match(input,ISBLANK,FOLLOW_ISBLANK_in_builtInCall6333);
 22143  32 
                     stream_ISBLANK.add(ISBLANK580);
 22144   
 
 22145   
 
 22146  32 
                     char_literal581=(Token)match(input,209,FOLLOW_209_in_builtInCall6335);
 22147  32 
                     stream_209.add(char_literal581);
 22148   
 
 22149   
 
 22150  52 
                     pushFollow(FOLLOW_expression_in_builtInCall6337);
 22151  52 
                     expression582=expression();
 22152   
 
 22153  52 
                     state._fsp--;
 22154   
 
 22155  32 
                     stream_expression.add(expression582.getTree());
 22156  20 
 
 22157  32 
                     char_literal583=(Token)match(input,210,FOLLOW_210_in_builtInCall6339);
 22158  32 
                     stream_210.add(char_literal583);
 22159   
 
 22160   
 
 22161  20 
                     // AST REWRITE
 22162   
                     // elements: ISBLANK, expression
 22163   
                     // token labels:
 22164  20 
                     // rule labels: retval
 22165   
                     // token list labels:
 22166   
                     // rule list labels:
 22167   
                     // wildcard labels:
 22168  78 
                     retval.tree = root_0;
 22169  78 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22170   
 
 22171  78 
                     root_0 = (Object)adaptor.nil();
 22172   
                     // 620:34: -> ^( ISBLANK expression )
 22173  46 
                     {
 22174   
                         // com\\googlecode\\sparkleg\\Sparql.g:620:37: ^( ISBLANK expression )
 22175   
                         {
 22176  32 
                         Object root_1 = (Object)adaptor.nil();
 22177  32 
                         root_1 = (Object)adaptor.becomeRoot(
 22178   
                         stream_ISBLANK.nextNode()
 22179   
                         , root_1);
 22180   
 
 22181  32 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22182  46 
 
 22183  78 
                         adaptor.addChild(root_0, root_1);
 22184   
                         }
 22185  46 
 
 22186   
                     }
 22187   
 
 22188  46 
 
 22189  32 
                     retval.tree = root_0;
 22190   
 
 22191   
                     }
 22192  32 
                     break;
 22193  46 
                 case 49 :
 22194   
                     // com\\googlecode\\sparkleg\\Sparql.g:621:7: ISLITERAL '(' expression ')'
 22195   
                     {
 22196  32 
                     ISLITERAL584=(Token)match(input,ISLITERAL,FOLLOW_ISLITERAL_in_builtInCall6356);
 22197  32 
                     stream_ISLITERAL.add(ISLITERAL584);
 22198   
 
 22199  532 
 
 22200  32 
                     char_literal585=(Token)match(input,209,FOLLOW_209_in_builtInCall6358);
 22201  32 
                     stream_209.add(char_literal585);
 22202  532 
 
 22203  532 
 
 22204  32 
                     pushFollow(FOLLOW_expression_in_builtInCall6360);
 22205  32 
                     expression586=expression();
 22206   
 
 22207  32 
                     state._fsp--;
 22208   
 
 22209  32 
                     stream_expression.add(expression586.getTree());
 22210   
 
 22211  32 
                     char_literal587=(Token)match(input,210,FOLLOW_210_in_builtInCall6362);
 22212  32 
                     stream_210.add(char_literal587);
 22213   
 
 22214   
 
 22215  532 
                     // AST REWRITE
 22216  532 
                     // elements: ISLITERAL, expression
 22217   
                     // token labels:
 22218   
                     // rule labels: retval
 22219   
                     // token list labels:
 22220   
                     // rule list labels:
 22221  42 
                     // wildcard labels:
 22222  32 
                     retval.tree = root_0;
 22223  32 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22224   
 
 22225  32 
                     root_0 = (Object)adaptor.nil();
 22226   
                     // 621:36: -> ^( ISLITERAL expression )
 22227   
                     {
 22228   
                         // com\\googlecode\\sparkleg\\Sparql.g:621:39: ^( ISLITERAL expression )
 22229   
                         {
 22230  74 
                         Object root_1 = (Object)adaptor.nil();
 22231  74 
                         root_1 = (Object)adaptor.becomeRoot(
 22232   
                         stream_ISLITERAL.nextNode()
 22233   
                         , root_1);
 22234  42 
 
 22235  32 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22236  42 
 
 22237  74 
                         adaptor.addChild(root_0, root_1);
 22238  42 
                         }
 22239  42 
 
 22240  42 
                     }
 22241  42 
 
 22242   
 
 22243  74 
                     retval.tree = root_0;
 22244   
 
 22245  42 
                     }
 22246  32 
                     break;
 22247   
                 case 50 :
 22248  42 
                     // com\\googlecode\\sparkleg\\Sparql.g:622:7: ISNUMERIC '(' expression ')'
 22249  42 
                     {
 22250  58 
                     ISNUMERIC588=(Token)match(input,ISNUMERIC,FOLLOW_ISNUMERIC_in_builtInCall6378);
 22251  58 
                     stream_ISNUMERIC.add(ISNUMERIC588);
 22252  42 
 
 22253  42 
 
 22254  58 
                     char_literal589=(Token)match(input,209,FOLLOW_209_in_builtInCall6380);
 22255  58 
                     stream_209.add(char_literal589);
 22256  42 
 
 22257  42 
 
 22258  16 
                     pushFollow(FOLLOW_expression_in_builtInCall6382);
 22259  16 
                     expression590=expression();
 22260   
 
 22261  16 
                     state._fsp--;
 22262  42 
 
 22263  58 
                     stream_expression.add(expression590.getTree());
 22264   
 
 22265  16 
                     char_literal591=(Token)match(input,210,FOLLOW_210_in_builtInCall6384);
 22266  58 
                     stream_210.add(char_literal591);
 22267  42 
 
 22268   
 
 22269   
                     // AST REWRITE
 22270  42 
                     // elements: ISNUMERIC, expression
 22271  42 
                     // token labels:
 22272   
                     // rule labels: retval
 22273  42 
                     // token list labels:
 22274   
                     // rule list labels:
 22275  42 
                     // wildcard labels:
 22276  16 
                     retval.tree = root_0;
 22277  58 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22278  42 
 
 22279  16 
                     root_0 = (Object)adaptor.nil();
 22280   
                     // 622:36: -> ^( ISNUMERIC expression )
 22281  42 
                     {
 22282  42 
                         // com\\googlecode\\sparkleg\\Sparql.g:622:39: ^( ISNUMERIC expression )
 22283   
                         {
 22284  58 
                         Object root_1 = (Object)adaptor.nil();
 22285  16 
                         root_1 = (Object)adaptor.becomeRoot(
 22286  42 
                         stream_ISNUMERIC.nextNode()
 22287   
                         , root_1);
 22288   
 
 22289  58 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22290  42 
 
 22291  16 
                         adaptor.addChild(root_0, root_1);
 22292   
                         }
 22293  12 
 
 22294   
                     }
 22295   
 
 22296   
 
 22297  16 
                     retval.tree = root_0;
 22298  42 
 
 22299   
                     }
 22300  16 
                     break;
 22301   
                 case 51 :
 22302  12 
                     // com\\googlecode\\sparkleg\\Sparql.g:623:7: regexExpression
 22303  12 
                     {
 22304  168 
                     pushFollow(FOLLOW_regexExpression_in_builtInCall6400);
 22305  168 
                     regexExpression592=regexExpression();
 22306  12 
 
 22307  180 
                     state._fsp--;
 22308   
 
 22309  180 
                     stream_regexExpression.add(regexExpression592.getTree());
 22310   
 
 22311  12 
                     // AST REWRITE
 22312   
                     // elements: regexExpression
 22313   
                     // token labels:
 22314   
                     // rule labels: retval
 22315   
                     // token list labels:
 22316   
                     // rule list labels:
 22317   
                     // wildcard labels:
 22318  168 
                     retval.tree = root_0;
 22319  210 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22320  42 
 
 22321  168 
                     root_0 = (Object)adaptor.nil();
 22322   
                     // 623:23: -> regexExpression
 22323   
                     {
 22324  168 
                         adaptor.addChild(root_0, stream_regexExpression.nextTree());
 22325   
 
 22326   
                     }
 22327   
 
 22328   
 
 22329  168 
                     retval.tree = root_0;
 22330  42 
 
 22331  42 
                     }
 22332  168 
                     break;
 22333  42 
                 case 52 :
 22334   
                     // com\\googlecode\\sparkleg\\Sparql.g:624:7: existsFunction
 22335   
                     {
 22336  80 
                     pushFollow(FOLLOW_existsFunction_in_builtInCall6412);
 22337  80 
                     existsFunction593=existsFunction();
 22338  42 
 
 22339  122 
                     state._fsp--;
 22340   
 
 22341  80 
                     stream_existsFunction.add(existsFunction593.getTree());
 22342   
 
 22343   
                     // AST REWRITE
 22344  138 
                     // elements: existsFunction
 22345  96 
                     // token labels:
 22346   
                     // rule labels: retval
 22347   
                     // token list labels:
 22348  42 
                     // rule list labels:
 22349   
                     // wildcard labels:
 22350  122 
                     retval.tree = root_0;
 22351  80 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22352   
 
 22353  80 
                     root_0 = (Object)adaptor.nil();
 22354   
                     // 624:22: -> existsFunction
 22355   
                     {
 22356  122 
                         adaptor.addChild(root_0, stream_existsFunction.nextTree());
 22357   
 
 22358   
                     }
 22359   
 
 22360  42 
 
 22361  80 
                     retval.tree = root_0;
 22362   
 
 22363  42 
                     }
 22364  122 
                     break;
 22365   
                 case 53 :
 22366   
                     // com\\googlecode\\sparkleg\\Sparql.g:625:7: notExistsFunction
 22367   
                     {
 22368  184 
                     pushFollow(FOLLOW_notExistsFunction_in_builtInCall6424);
 22369  184 
                     notExistsFunction594=notExistsFunction();
 22370   
 
 22371  184 
                     state._fsp--;
 22372   
 
 22373  184 
                     stream_notExistsFunction.add(notExistsFunction594.getTree());
 22374   
 
 22375   
                     // AST REWRITE
 22376  42 
                     // elements: notExistsFunction
 22377  42 
                     // token labels:
 22378   
                     // rule labels: retval
 22379   
                     // token list labels:
 22380   
                     // rule list labels:
 22381   
                     // wildcard labels:
 22382  4 
                     retval.tree = root_0;
 22383  184 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22384  4 
 
 22385  184 
                     root_0 = (Object)adaptor.nil();
 22386   
                     // 625:25: -> notExistsFunction
 22387   
                     {
 22388  184 
                         adaptor.addChild(root_0, stream_notExistsFunction.nextTree());
 22389   
 
 22390   
                     }
 22391  4 
 
 22392  4 
 
 22393  184 
                     retval.tree = root_0;
 22394   
 
 22395  4 
                     }
 22396   
                     break;
 22397  4 
 
 22398  4 
             }
 22399  2132 
             retval.stop = input.LT(-1);
 22400  4 
 
 22401  4 
 
 22402  2132 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22403  2128 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22404  4 
 
 22405   
         }
 22406  4 
         catch (RecognitionException re) {
 22407  0 
             reportError(re);
 22408  0 
             recover(input,re);
 22409  4 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22410  4 
 
 22411  4 
         }
 22412  4 
 
 22413  4 
         finally {
 22414  4 
                 // do for sure before leaving
 22415  2132 
         }
 22416  2132 
         return retval;
 22417  4 
     }
 22418  4 
     // $ANTLR end "builtInCall"
 22419   
 
 22420   
 
 22421  168 
     public static class regexExpression_return extends ParserRuleReturnScope {
 22422   
         Object tree;
 22423  4 
         public Object getTree() { return tree; }
 22424  4 
     };
 22425   
 
 22426   
 
 22427  4 
     // $ANTLR start "regexExpression"
 22428  4 
     // com\\googlecode\\sparkleg\\Sparql.g:628:1: regexExpression : REGEX '(' expression ',' expression ( ',' expression )? ')' -> ^( REGEX ( expression )* ) ;
 22429   
     public final SparqlParser.regexExpression_return regexExpression() throws RecognitionException {
 22430  168 
         SparqlParser.regexExpression_return retval = new SparqlParser.regexExpression_return();
 22431  172 
         retval.start = input.LT(1);
 22432  4 
 
 22433   
 
 22434  172 
         Object root_0 = null;
 22435   
 
 22436  172 
         Token REGEX595=null;
 22437  168 
         Token char_literal596=null;
 22438  172 
         Token char_literal598=null;
 22439  172 
         Token char_literal600=null;
 22440  168 
         Token char_literal602=null;
 22441  168 
         SparqlParser.expression_return expression597 =null;
 22442  4 
 
 22443  172 
         SparqlParser.expression_return expression599 =null;
 22444   
 
 22445  172 
         SparqlParser.expression_return expression601 =null;
 22446   
 
 22447  4 
 
 22448  168 
         Object REGEX595_tree=null;
 22449  168 
         Object char_literal596_tree=null;
 22450  172 
         Object char_literal598_tree=null;
 22451  172 
         Object char_literal600_tree=null;
 22452  168 
         Object char_literal602_tree=null;
 22453  168 
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 22454  170 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 22455  168 
         RewriteRuleTokenStream stream_REGEX=new RewriteRuleTokenStream(adaptor,"token REGEX");
 22456  168 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 22457  168 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22458   
         try {
 22459  4 
             // com\\googlecode\\sparkleg\\Sparql.g:629:5: ( REGEX '(' expression ',' expression ( ',' expression )? ')' -> ^( REGEX ( expression )* ) )
 22460   
             // com\\googlecode\\sparkleg\\Sparql.g:629:7: REGEX '(' expression ',' expression ( ',' expression )? ')'
 22461   
             {
 22462  168 
             REGEX595=(Token)match(input,REGEX,FOLLOW_REGEX_in_regexExpression6445);
 22463  170 
             stream_REGEX.add(REGEX595);
 22464  2 
 
 22465   
 
 22466  168 
             char_literal596=(Token)match(input,209,FOLLOW_209_in_regexExpression6447);
 22467  170 
             stream_209.add(char_literal596);
 22468  2 
 
 22469   
 
 22470  170 
             pushFollow(FOLLOW_expression_in_regexExpression6449);
 22471  168 
             expression597=expression();
 22472  2 
 
 22473  168 
             state._fsp--;
 22474   
 
 22475  168 
             stream_expression.add(expression597.getTree());
 22476   
 
 22477  168 
             char_literal598=(Token)match(input,211,FOLLOW_211_in_regexExpression6451);
 22478  168 
             stream_211.add(char_literal598);
 22479   
 
 22480  4 
 
 22481  172 
             pushFollow(FOLLOW_expression_in_regexExpression6453);
 22482  168 
             expression599=expression();
 22483   
 
 22484  168 
             state._fsp--;
 22485   
 
 22486  168 
             stream_expression.add(expression599.getTree());
 22487   
 
 22488   
             // com\\googlecode\\sparkleg\\Sparql.g:629:43: ( ',' expression )?
 22489  168 
             int alt125=2;
 22490  168 
             switch ( input.LA(1) ) {
 22491  4 
                 case 211:
 22492  4 
                     {
 22493  48 
                     alt125=1;
 22494  4 
                     }
 22495   
                     break;
 22496   
             }
 22497   
 
 22498  168 
             switch (alt125) {
 22499  4 
                 case 1 :
 22500  4 
                     // com\\googlecode\\sparkleg\\Sparql.g:629:44: ',' expression
 22501   
                     {
 22502  48 
                     char_literal600=(Token)match(input,211,FOLLOW_211_in_regexExpression6456);
 22503  48 
                     stream_211.add(char_literal600);
 22504   
 
 22505  14 
 
 22506  58 
                     pushFollow(FOLLOW_expression_in_regexExpression6458);
 22507  48 
                     expression601=expression();
 22508   
 
 22509  52 
                     state._fsp--;
 22510   
 
 22511  52 
                     stream_expression.add(expression601.getTree());
 22512   
 
 22513   
                     }
 22514   
                     break;
 22515   
 
 22516   
             }
 22517  4 
 
 22518   
 
 22519  168 
             char_literal602=(Token)match(input,210,FOLLOW_210_in_regexExpression6462);
 22520  168 
             stream_210.add(char_literal602);
 22521  4 
 
 22522   
 
 22523   
             // AST REWRITE
 22524  4 
             // elements: expression, REGEX
 22525  4 
             // token labels:
 22526   
             // rule labels: retval
 22527   
             // token list labels:
 22528   
             // rule list labels:
 22529   
             // wildcard labels:
 22530  168 
             retval.tree = root_0;
 22531  168 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22532   
 
 22533  168 
             root_0 = (Object)adaptor.nil();
 22534   
             // 629:65: -> ^( REGEX ( expression )* )
 22535   
             {
 22536   
                 // com\\googlecode\\sparkleg\\Sparql.g:629:68: ^( REGEX ( expression )* )
 22537  4 
                 {
 22538  172 
                 Object root_1 = (Object)adaptor.nil();
 22539  168 
                 root_1 = (Object)adaptor.becomeRoot(
 22540   
                 stream_REGEX.nextNode()
 22541   
                 , root_1);
 22542   
 
 22543  6 
                 // com\\googlecode\\sparkleg\\Sparql.g:629:76: ( expression )*
 22544  552 
                 while ( stream_expression.hasNext() ) {
 22545  384 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22546   
 
 22547   
                 }
 22548  168 
                 stream_expression.reset();
 22549   
 
 22550  168 
                 adaptor.addChild(root_0, root_1);
 22551   
                 }
 22552  6 
 
 22553  6 
             }
 22554   
 
 22555   
 
 22556  174 
             retval.tree = root_0;
 22557   
 
 22558  6 
             }
 22559  6 
 
 22560  174 
             retval.stop = input.LT(-1);
 22561  6 
 
 22562  6 
 
 22563  174 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22564  174 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22565   
 
 22566  6 
         }
 22567  0 
         catch (RecognitionException re) {
 22568  6 
             reportError(re);
 22569  0 
             recover(input,re);
 22570  6 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22571   
 
 22572   
         }
 22573  6 
 
 22574  6 
         finally {
 22575  6 
                 // do for sure before leaving
 22576  174 
         }
 22577  174 
         return retval;
 22578  6 
     }
 22579  6 
     // $ANTLR end "regexExpression"
 22580  6 
 
 22581  6 
 
 22582  16 
     public static class subStringExpression_return extends ParserRuleReturnScope {
 22583  6 
         Object tree;
 22584  16 
         public Object getTree() { return tree; }
 22585   
     };
 22586   
 
 22587   
 
 22588  6 
     // $ANTLR start "subStringExpression"
 22589  6 
     // com\\googlecode\\sparkleg\\Sparql.g:632:1: subStringExpression : SUBSTR '(' expression ',' expression ( ',' expression )? ')' -> ^( SUBSTR ( expression )* ) ;
 22590   
     public final SparqlParser.subStringExpression_return subStringExpression() throws RecognitionException {
 22591  16 
         SparqlParser.subStringExpression_return retval = new SparqlParser.subStringExpression_return();
 22592  22 
         retval.start = input.LT(1);
 22593  6 
 
 22594   
 
 22595  16 
         Object root_0 = null;
 22596  6 
 
 22597  22 
         Token SUBSTR603=null;
 22598  16 
         Token char_literal604=null;
 22599  22 
         Token char_literal606=null;
 22600  16 
         Token char_literal608=null;
 22601  22 
         Token char_literal610=null;
 22602  16 
         SparqlParser.expression_return expression605 =null;
 22603  6 
 
 22604  22 
         SparqlParser.expression_return expression607 =null;
 22605   
 
 22606  16 
         SparqlParser.expression_return expression609 =null;
 22607  6 
 
 22608  6 
 
 22609  16 
         Object SUBSTR603_tree=null;
 22610  22 
         Object char_literal604_tree=null;
 22611  16 
         Object char_literal606_tree=null;
 22612  22 
         Object char_literal608_tree=null;
 22613  16 
         Object char_literal610_tree=null;
 22614  22 
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 22615  22 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 22616  16 
         RewriteRuleTokenStream stream_SUBSTR=new RewriteRuleTokenStream(adaptor,"token SUBSTR");
 22617  16 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 22618  22 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22619  6 
         try {
 22620   
             // com\\googlecode\\sparkleg\\Sparql.g:633:5: ( SUBSTR '(' expression ',' expression ( ',' expression )? ')' -> ^( SUBSTR ( expression )* ) )
 22621  6 
             // com\\googlecode\\sparkleg\\Sparql.g:633:7: SUBSTR '(' expression ',' expression ( ',' expression )? ')'
 22622   
             {
 22623  22 
             SUBSTR603=(Token)match(input,SUBSTR,FOLLOW_SUBSTR_in_subStringExpression6492);
 22624  16 
             stream_SUBSTR.add(SUBSTR603);
 22625   
 
 22626  6 
 
 22627  22 
             char_literal604=(Token)match(input,209,FOLLOW_209_in_subStringExpression6494);
 22628  16 
             stream_209.add(char_literal604);
 22629   
 
 22630   
 
 22631  16 
             pushFollow(FOLLOW_expression_in_subStringExpression6496);
 22632  16 
             expression605=expression();
 22633   
 
 22634  16 
             state._fsp--;
 22635  6 
 
 22636  16 
             stream_expression.add(expression605.getTree());
 22637   
 
 22638  16 
             char_literal606=(Token)match(input,211,FOLLOW_211_in_subStringExpression6498);
 22639  16 
             stream_211.add(char_literal606);
 22640   
 
 22641   
 
 22642  16 
             pushFollow(FOLLOW_expression_in_subStringExpression6500);
 22643  16 
             expression607=expression();
 22644   
 
 22645  16 
             state._fsp--;
 22646   
 
 22647  16 
             stream_expression.add(expression607.getTree());
 22648   
 
 22649   
             // com\\googlecode\\sparkleg\\Sparql.g:633:44: ( ',' expression )?
 22650  16 
             int alt126=2;
 22651  16 
             switch ( input.LA(1) ) {
 22652   
                 case 211:
 22653   
                     {
 22654  8 
                     alt126=1;
 22655   
                     }
 22656  6 
                     break;
 22657  6 
             }
 22658   
 
 22659  16 
             switch (alt126) {
 22660   
                 case 1 :
 22661   
                     // com\\googlecode\\sparkleg\\Sparql.g:633:45: ',' expression
 22662   
                     {
 22663  8 
                     char_literal608=(Token)match(input,211,FOLLOW_211_in_subStringExpression6503);
 22664  8 
                     stream_211.add(char_literal608);
 22665   
 
 22666   
 
 22667  14 
                     pushFollow(FOLLOW_expression_in_subStringExpression6505);
 22668  14 
                     expression609=expression();
 22669   
 
 22670  14 
                     state._fsp--;
 22671   
 
 22672  8 
                     stream_expression.add(expression609.getTree());
 22673   
 
 22674   
                     }
 22675  6 
                     break;
 22676  6 
 
 22677   
             }
 22678   
 
 22679   
 
 22680  16 
             char_literal610=(Token)match(input,210,FOLLOW_210_in_subStringExpression6509);
 22681  40 
             stream_210.add(char_literal610);
 22682  18 
 
 22683   
 
 22684   
             // AST REWRITE
 22685  6 
             // elements: SUBSTR, expression
 22686   
             // token labels:
 22687  6 
             // rule labels: retval
 22688   
             // token list labels:
 22689   
             // rule list labels:
 22690   
             // wildcard labels:
 22691  16 
             retval.tree = root_0;
 22692  16 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22693  6 
 
 22694  16 
             root_0 = (Object)adaptor.nil();
 22695   
             // 633:66: -> ^( SUBSTR ( expression )* )
 22696   
             {
 22697  6 
                 // com\\googlecode\\sparkleg\\Sparql.g:633:69: ^( SUBSTR ( expression )* )
 22698   
                 {
 22699  16 
                 Object root_1 = (Object)adaptor.nil();
 22700  22 
                 root_1 = (Object)adaptor.becomeRoot(
 22701  6 
                 stream_SUBSTR.nextNode()
 22702   
                 , root_1);
 22703   
 
 22704   
                 // com\\googlecode\\sparkleg\\Sparql.g:633:78: ( expression )*
 22705  56 
                 while ( stream_expression.hasNext() ) {
 22706  40 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22707   
 
 22708   
                 }
 22709  16 
                 stream_expression.reset();
 22710   
 
 22711  16 
                 adaptor.addChild(root_0, root_1);
 22712   
                 }
 22713  6 
 
 22714  6 
             }
 22715   
 
 22716   
 
 22717  16 
             retval.tree = root_0;
 22718   
 
 22719  20 
             }
 22720   
 
 22721  16 
             retval.stop = input.LT(-1);
 22722   
 
 22723   
 
 22724  16 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22725  16 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22726   
 
 22727   
         }
 22728  20 
         catch (RecognitionException re) {
 22729  20 
             reportError(re);
 22730  0 
             recover(input,re);
 22731  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22732  20 
 
 22733   
         }
 22734  20 
 
 22735  20 
         finally {
 22736   
                 // do for sure before leaving
 22737  16 
         }
 22738  36 
         return retval;
 22739  20 
     }
 22740  20 
     // $ANTLR end "subStringExpression"
 22741   
 
 22742   
 
 22743  24 
     public static class strReplaceExpression_return extends ParserRuleReturnScope {
 22744   
         Object tree;
 22745  20 
         public Object getTree() { return tree; }
 22746  20 
     };
 22747   
 
 22748   
 
 22749  20 
     // $ANTLR start "strReplaceExpression"
 22750  20 
     // com\\googlecode\\sparkleg\\Sparql.g:636:1: strReplaceExpression : REPLACE '(' expression ',' expression ',' expression ( ',' expression )? ')' -> ^( REPLACE ( expression )* ) ;
 22751   
     public final SparqlParser.strReplaceExpression_return strReplaceExpression() throws RecognitionException {
 22752  44 
         SparqlParser.strReplaceExpression_return retval = new SparqlParser.strReplaceExpression_return();
 22753  24 
         retval.start = input.LT(1);
 22754  20 
 
 22755   
 
 22756  24 
         Object root_0 = null;
 22757   
 
 22758  24 
         Token REPLACE611=null;
 22759  24 
         Token char_literal612=null;
 22760  24 
         Token char_literal614=null;
 22761  24 
         Token char_literal616=null;
 22762  24 
         Token char_literal618=null;
 22763  44 
         Token char_literal620=null;
 22764  44 
         SparqlParser.expression_return expression613 =null;
 22765   
 
 22766  44 
         SparqlParser.expression_return expression615 =null;
 22767   
 
 22768  24 
         SparqlParser.expression_return expression617 =null;
 22769   
 
 22770  24 
         SparqlParser.expression_return expression619 =null;
 22771  20 
 
 22772  20 
 
 22773  24 
         Object REPLACE611_tree=null;
 22774  24 
         Object char_literal612_tree=null;
 22775  24 
         Object char_literal614_tree=null;
 22776  44 
         Object char_literal616_tree=null;
 22777  24 
         Object char_literal618_tree=null;
 22778  44 
         Object char_literal620_tree=null;
 22779  24 
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 22780  24 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 22781  24 
         RewriteRuleTokenStream stream_REPLACE=new RewriteRuleTokenStream(adaptor,"token REPLACE");
 22782  24 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 22783  24 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22784  20 
         try {
 22785   
             // com\\googlecode\\sparkleg\\Sparql.g:637:5: ( REPLACE '(' expression ',' expression ',' expression ( ',' expression )? ')' -> ^( REPLACE ( expression )* ) )
 22786   
             // com\\googlecode\\sparkleg\\Sparql.g:637:7: REPLACE '(' expression ',' expression ',' expression ( ',' expression )? ')'
 22787   
             {
 22788  44 
             REPLACE611=(Token)match(input,REPLACE,FOLLOW_REPLACE_in_strReplaceExpression6543);
 22789  24 
             stream_REPLACE.add(REPLACE611);
 22790   
 
 22791  20 
 
 22792  44 
             char_literal612=(Token)match(input,209,FOLLOW_209_in_strReplaceExpression6545);
 22793  24 
             stream_209.add(char_literal612);
 22794   
 
 22795   
 
 22796  24 
             pushFollow(FOLLOW_expression_in_strReplaceExpression6547);
 22797  24 
             expression613=expression();
 22798   
 
 22799  24 
             state._fsp--;
 22800   
 
 22801  24 
             stream_expression.add(expression613.getTree());
 22802   
 
 22803  24 
             char_literal614=(Token)match(input,211,FOLLOW_211_in_strReplaceExpression6549);
 22804  44 
             stream_211.add(char_literal614);
 22805  20 
 
 22806   
 
 22807  24 
             pushFollow(FOLLOW_expression_in_strReplaceExpression6551);
 22808  24 
             expression615=expression();
 22809   
 
 22810  24 
             state._fsp--;
 22811   
 
 22812  24 
             stream_expression.add(expression615.getTree());
 22813   
 
 22814  24 
             char_literal616=(Token)match(input,211,FOLLOW_211_in_strReplaceExpression6553);
 22815  24 
             stream_211.add(char_literal616);
 22816   
 
 22817   
 
 22818  24 
             pushFollow(FOLLOW_expression_in_strReplaceExpression6555);
 22819  70 
             expression617=expression();
 22820  46 
 
 22821  24 
             state._fsp--;
 22822   
 
 22823  70 
             stream_expression.add(expression617.getTree());
 22824   
 
 22825  46 
             // com\\googlecode\\sparkleg\\Sparql.g:637:60: ( ',' expression )?
 22826  70 
             int alt127=2;
 22827  70 
             switch ( input.LA(1) ) {
 22828   
                 case 211:
 22829   
                     {
 22830  46 
                     alt127=1;
 22831  46 
                     }
 22832  46 
                     break;
 22833  46 
             }
 22834  46 
 
 22835  24 
             switch (alt127) {
 22836   
                 case 1 :
 22837   
                     // com\\googlecode\\sparkleg\\Sparql.g:637:61: ',' expression
 22838   
                     {
 22839  46 
                     char_literal618=(Token)match(input,211,FOLLOW_211_in_strReplaceExpression6558);
 22840  46 
                     stream_211.add(char_literal618);
 22841   
 
 22842   
 
 22843  46 
                     pushFollow(FOLLOW_expression_in_strReplaceExpression6560);
 22844  46 
                     expression619=expression();
 22845   
 
 22846  0 
                     state._fsp--;
 22847  46 
 
 22848  46 
                     stream_expression.add(expression619.getTree());
 22849   
 
 22850  46 
                     }
 22851   
                     break;
 22852  46 
 
 22853   
             }
 22854   
 
 22855   
 
 22856  24 
             char_literal620=(Token)match(input,210,FOLLOW_210_in_strReplaceExpression6564);
 22857  24 
             stream_210.add(char_literal620);
 22858   
 
 22859   
 
 22860   
             // AST REWRITE
 22861  46 
             // elements: expression, REPLACE
 22862  46 
             // token labels:
 22863   
             // rule labels: retval
 22864  46 
             // token list labels:
 22865   
             // rule list labels:
 22866   
             // wildcard labels:
 22867  24 
             retval.tree = root_0;
 22868  24 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22869  46 
 
 22870  70 
             root_0 = (Object)adaptor.nil();
 22871   
             // 637:82: -> ^( REPLACE ( expression )* )
 22872   
             {
 22873   
                 // com\\googlecode\\sparkleg\\Sparql.g:637:85: ^( REPLACE ( expression )* )
 22874  46 
                 {
 22875  24 
                 Object root_1 = (Object)adaptor.nil();
 22876  70 
                 root_1 = (Object)adaptor.becomeRoot(
 22877   
                 stream_REPLACE.nextNode()
 22878   
                 , root_1);
 22879   
 
 22880   
                 // com\\googlecode\\sparkleg\\Sparql.g:637:95: ( expression )*
 22881  96 
                 while ( stream_expression.hasNext() ) {
 22882  118 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22883   
 
 22884   
                 }
 22885  24 
                 stream_expression.reset();
 22886  46 
 
 22887  24 
                 adaptor.addChild(root_0, root_1);
 22888   
                 }
 22889  46 
 
 22890  46 
             }
 22891   
 
 22892   
 
 22893  24 
             retval.tree = root_0;
 22894   
 
 22895   
             }
 22896   
 
 22897  24 
             retval.stop = input.LT(-1);
 22898   
 
 22899   
 
 22900  24 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22901  24 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22902  46 
 
 22903  46 
         }
 22904  0 
         catch (RecognitionException re) {
 22905  0 
             reportError(re);
 22906  0 
             recover(input,re);
 22907  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22908  106 
 
 22909   
         }
 22910  106 
 
 22911  0 
         finally {
 22912   
                 // do for sure before leaving
 22913  24 
         }
 22914  24 
         return retval;
 22915   
     }
 22916   
     // $ANTLR end "strReplaceExpression"
 22917  106 
 
 22918  106 
 
 22919  80 
     public static class existsFunction_return extends ParserRuleReturnScope {
 22920   
         Object tree;
 22921  106 
         public Object getTree() { return tree; }
 22922   
     };
 22923  106 
 
 22924  106 
 
 22925  106 
     // $ANTLR start "existsFunction"
 22926  106 
     // com\\googlecode\\sparkleg\\Sparql.g:640:1: existsFunction : EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) ;
 22927  106 
     public final SparqlParser.existsFunction_return existsFunction() throws RecognitionException {
 22928  186 
         SparqlParser.existsFunction_return retval = new SparqlParser.existsFunction_return();
 22929  186 
         retval.start = input.LT(1);
 22930  106 
 
 22931  106 
 
 22932  186 
         Object root_0 = null;
 22933  106 
 
 22934  186 
         Token EXISTS621=null;
 22935  186 
         SparqlParser.groupGraphPattern_return groupGraphPattern622 =null;
 22936  106 
 
 22937  106 
 
 22938  186 
         Object EXISTS621_tree=null;
 22939  186 
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22940  186 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22941  106 
         try {
 22942  106 
             // com\\googlecode\\sparkleg\\Sparql.g:641:5: ( EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) )
 22943  106 
             // com\\googlecode\\sparkleg\\Sparql.g:641:7: EXISTS groupGraphPattern
 22944  106 
             {
 22945  186 
             EXISTS621=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_existsFunction6590);
 22946  186 
             stream_EXISTS.add(EXISTS621);
 22947  106 
 
 22948  106 
 
 22949  186 
             pushFollow(FOLLOW_groupGraphPattern_in_existsFunction6592);
 22950  186 
             groupGraphPattern622=groupGraphPattern();
 22951  106 
 
 22952  186 
             state._fsp--;
 22953  106 
 
 22954  186 
             stream_groupGraphPattern.add(groupGraphPattern622.getTree());
 22955  106 
 
 22956   
             // AST REWRITE
 22957  106 
             // elements: EXISTS, groupGraphPattern
 22958   
             // token labels:
 22959  106 
             // rule labels: retval
 22960   
             // token list labels:
 22961  106 
             // rule list labels:
 22962   
             // wildcard labels:
 22963  186 
             retval.tree = root_0;
 22964  80 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22965  106 
 
 22966  80 
             root_0 = (Object)adaptor.nil();
 22967  106 
             // 641:32: -> ^( EXISTS groupGraphPattern )
 22968   
             {
 22969  106 
                 // com\\googlecode\\sparkleg\\Sparql.g:641:35: ^( EXISTS groupGraphPattern )
 22970   
                 {
 22971  80 
                 Object root_1 = (Object)adaptor.nil();
 22972  186 
                 root_1 = (Object)adaptor.becomeRoot(
 22973  106 
                 stream_EXISTS.nextNode()
 22974  106 
                 , root_1);
 22975  106 
 
 22976  186 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22977  106 
 
 22978  186 
                 adaptor.addChild(root_0, root_1);
 22979  106 
                 }
 22980  106 
 
 22981  106 
             }
 22982  106 
 
 22983  106 
 
 22984  186 
             retval.tree = root_0;
 22985  106 
 
 22986  106 
             }
 22987  106 
 
 22988  186 
             retval.stop = input.LT(-1);
 22989  106 
 
 22990  106 
 
 22991  186 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22992  186 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22993  106 
 
 22994  106 
         }
 22995  106 
         catch (RecognitionException re) {
 22996  106 
             reportError(re);
 22997  106 
             recover(input,re);
 22998  106 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22999  106 
 
 23000  106 
         }
 23001  106 
 
 23002  106 
         finally {
 23003  106 
                 // do for sure before leaving
 23004  186 
         }
 23005  186 
         return retval;
 23006  106 
     }
 23007  106 
     // $ANTLR end "existsFunction"
 23008  106 
 
 23009  106 
 
 23010  106 
     public static class notExistsFunction_return extends ParserRuleReturnScope {
 23011  106 
         Object tree;
 23012  106 
         public Object getTree() { return tree; }
 23013  106 
     };
 23014  106 
 
 23015  106 
 
 23016  106 
     // $ANTLR start "notExistsFunction"
 23017  106 
     // com\\googlecode\\sparkleg\\Sparql.g:644:1: notExistsFunction : NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) ;
 23018  106 
     public final SparqlParser.notExistsFunction_return notExistsFunction() throws RecognitionException {
 23019  290 
         SparqlParser.notExistsFunction_return retval = new SparqlParser.notExistsFunction_return();
 23020  184 
         retval.start = input.LT(1);
 23021   
 
 23022  106 
 
 23023  290 
         Object root_0 = null;
 23024   
 
 23025  184 
         Token NOT623=null;
 23026  218 
         Token EXISTS624=null;
 23027  184 
         SparqlParser.groupGraphPattern_return groupGraphPattern625 =null;
 23028  34 
 
 23029   
 
 23030  184 
         Object NOT623_tree=null;
 23031  196 
         Object EXISTS624_tree=null;
 23032  184 
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 23033  196 
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 23034  184 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 23035   
         try {
 23036  14 
             // com\\googlecode\\sparkleg\\Sparql.g:645:5: ( NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) )
 23037   
             // com\\googlecode\\sparkleg\\Sparql.g:645:7: NOT EXISTS groupGraphPattern
 23038  14 
             {
 23039  184 
             NOT623=(Token)match(input,NOT,FOLLOW_NOT_in_notExistsFunction6617);
 23040  184 
             stream_NOT.add(NOT623);
 23041  10 
 
 23042   
 
 23043  194 
             EXISTS624=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_notExistsFunction6619);
 23044  184 
             stream_EXISTS.add(EXISTS624);
 23045   
 
 23046  24 
 
 23047  184 
             pushFollow(FOLLOW_groupGraphPattern_in_notExistsFunction6621);
 23048  208 
             groupGraphPattern625=groupGraphPattern();
 23049   
 
 23050  184 
             state._fsp--;
 23051  6 
 
 23052  184 
             stream_groupGraphPattern.add(groupGraphPattern625.getTree());
 23053  6 
 
 23054   
             // AST REWRITE
 23055   
             // elements: groupGraphPattern
 23056  6 
             // token labels:
 23057   
             // rule labels: retval
 23058  6 
             // token list labels:
 23059   
             // rule list labels:
 23060   
             // wildcard labels:
 23061  184 
             retval.tree = root_0;
 23062  184 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23063   
 
 23064  184 
             root_0 = (Object)adaptor.nil();
 23065   
             // 645:36: -> ^( NOT_EXISTS groupGraphPattern )
 23066   
             {
 23067  106 
                 // com\\googlecode\\sparkleg\\Sparql.g:645:39: ^( NOT_EXISTS groupGraphPattern )
 23068   
                 {
 23069  184 
                 Object root_1 = (Object)adaptor.nil();
 23070  184 
                 root_1 = (Object)adaptor.becomeRoot(
 23071  34 
                 (Object)adaptor.create(NOT_EXISTS, "NOT_EXISTS")
 23072  34 
                 , root_1);
 23073   
 
 23074  184 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 23075  34 
 
 23076  218 
                 adaptor.addChild(root_0, root_1);
 23077   
                 }
 23078   
 
 23079   
             }
 23080  34 
 
 23081  34 
 
 23082  184 
             retval.tree = root_0;
 23083   
 
 23084   
             }
 23085   
 
 23086  184 
             retval.stop = input.LT(-1);
 23087   
 
 23088   
 
 23089  218 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23090  184 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23091   
 
 23092   
         }
 23093  0 
         catch (RecognitionException re) {
 23094  0 
             reportError(re);
 23095  0 
             recover(input,re);
 23096  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23097   
 
 23098   
         }
 23099   
 
 23100  0 
         finally {
 23101   
                 // do for sure before leaving
 23102  184 
         }
 23103  184 
         return retval;
 23104  34 
     }
 23105  34 
     // $ANTLR end "notExistsFunction"
 23106   
 
 23107   
 
 23108  14 
     public static class aggregate_return extends ParserRuleReturnScope {
 23109   
         Object tree;
 23110  14 
         public Object getTree() { return tree; }
 23111   
     };
 23112   
 
 23113   
 
 23114   
     // $ANTLR start "aggregate"
 23115   
     // com\\googlecode\\sparkleg\\Sparql.g:648:1: aggregate : ( COUNT '(' ( DISTINCT )? ( '*' | expression ) ')' -> ^( COUNT ( DISTINCT )* ( '*' )* ( expression )* ) | SUM '(' ( DISTINCT )? expression ')' -> ^( SUM ( DISTINCT )* expression ) | MIN '(' ( DISTINCT )? expression ')' -> ^( MIN ( DISTINCT )* expression ) | MAX '(' ( DISTINCT )? expression ')' -> ^( MAX ( DISTINCT )* expression ) | AVG '(' ( DISTINCT )? expression ')' -> ^( AVG ( DISTINCT )* expression ) | SAMPLE '(' ( DISTINCT )? expression ')' -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT '(' ( DISTINCT )? expression ( ';' SEPARATOR '=' string )? ')' -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) );
 23116   
     public final SparqlParser.aggregate_return aggregate() throws RecognitionException {
 23117  424 
         SparqlParser.aggregate_return retval = new SparqlParser.aggregate_return();
 23118  424 
         retval.start = input.LT(1);
 23119   
 
 23120   
 
 23121  424 
         Object root_0 = null;
 23122   
 
 23123  424 
         Token COUNT626=null;
 23124  424 
         Token char_literal627=null;
 23125  424 
         Token DISTINCT628=null;
 23126  424 
         Token char_literal629=null;
 23127  424 
         Token char_literal631=null;
 23128  424 
         Token SUM632=null;
 23129  424 
         Token char_literal633=null;
 23130  424 
         Token DISTINCT634=null;
 23131  424 
         Token char_literal636=null;
 23132  424 
         Token MIN637=null;
 23133  424 
         Token char_literal638=null;
 23134  424 
         Token DISTINCT639=null;
 23135  424 
         Token char_literal641=null;
 23136  424 
         Token MAX642=null;
 23137  424 
         Token char_literal643=null;
 23138  424 
         Token DISTINCT644=null;
 23139  424 
         Token char_literal646=null;
 23140  424 
         Token AVG647=null;
 23141  424 
         Token char_literal648=null;
 23142  424 
         Token DISTINCT649=null;
 23143  424 
         Token char_literal651=null;
 23144  424 
         Token SAMPLE652=null;
 23145  424 
         Token char_literal653=null;
 23146  424 
         Token DISTINCT654=null;
 23147  424 
         Token char_literal656=null;
 23148  424 
         Token GROUP_CONCAT657=null;
 23149  424 
         Token char_literal658=null;
 23150  424 
         Token DISTINCT659=null;
 23151  424 
         Token char_literal661=null;
 23152  424 
         Token SEPARATOR662=null;
 23153  424 
         Token char_literal663=null;
 23154  424 
         Token char_literal665=null;
 23155  424 
         SparqlParser.expression_return expression630 =null;
 23156   
 
 23157  424 
         SparqlParser.expression_return expression635 =null;
 23158   
 
 23159  424 
         SparqlParser.expression_return expression640 =null;
 23160   
 
 23161  424 
         SparqlParser.expression_return expression645 =null;
 23162   
 
 23163  424 
         SparqlParser.expression_return expression650 =null;
 23164   
 
 23165  424 
         SparqlParser.expression_return expression655 =null;
 23166   
 
 23167  424 
         SparqlParser.expression_return expression660 =null;
 23168   
 
 23169  424 
         SparqlParser.string_return string664 =null;
 23170   
 
 23171   
 
 23172  424 
         Object COUNT626_tree=null;
 23173  424 
         Object char_literal627_tree=null;
 23174  424 
         Object DISTINCT628_tree=null;
 23175  424 
         Object char_literal629_tree=null;
 23176  424 
         Object char_literal631_tree=null;
 23177  424 
         Object SUM632_tree=null;
 23178  424 
         Object char_literal633_tree=null;
 23179  424 
         Object DISTINCT634_tree=null;
 23180  424 
         Object char_literal636_tree=null;
 23181  424 
         Object MIN637_tree=null;
 23182  424 
         Object char_literal638_tree=null;
 23183  424 
         Object DISTINCT639_tree=null;
 23184  424 
         Object char_literal641_tree=null;
 23185  424 
         Object MAX642_tree=null;
 23186  424 
         Object char_literal643_tree=null;
 23187  424 
         Object DISTINCT644_tree=null;
 23188  424 
         Object char_literal646_tree=null;
 23189  424 
         Object AVG647_tree=null;
 23190  424 
         Object char_literal648_tree=null;
 23191  424 
         Object DISTINCT649_tree=null;
 23192  424 
         Object char_literal651_tree=null;
 23193  424 
         Object SAMPLE652_tree=null;
 23194  424 
         Object char_literal653_tree=null;
 23195  444 
         Object DISTINCT654_tree=null;
 23196  424 
         Object char_literal656_tree=null;
 23197  444 
         Object GROUP_CONCAT657_tree=null;
 23198  424 
         Object char_literal658_tree=null;
 23199  424 
         Object DISTINCT659_tree=null;
 23200  424 
         Object char_literal661_tree=null;
 23201  424 
         Object SEPARATOR662_tree=null;
 23202  424 
         Object char_literal663_tree=null;
 23203  424 
         Object char_literal665_tree=null;
 23204  424 
         RewriteRuleTokenStream stream_212=new RewriteRuleTokenStream(adaptor,"token 212");
 23205  424 
         RewriteRuleTokenStream stream_SAMPLE=new RewriteRuleTokenStream(adaptor,"token SAMPLE");
 23206  458 
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 23207  424 
         RewriteRuleTokenStream stream_AVG=new RewriteRuleTokenStream(adaptor,"token AVG");
 23208  424 
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 23209  424 
         RewriteRuleTokenStream stream_GROUP_CONCAT=new RewriteRuleTokenStream(adaptor,"token GROUP_CONCAT");
 23210  438 
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 23211  438 
         RewriteRuleTokenStream stream_MAX=new RewriteRuleTokenStream(adaptor,"token MAX");
 23212  424 
         RewriteRuleTokenStream stream_COUNT=new RewriteRuleTokenStream(adaptor,"token COUNT");
 23213  424 
         RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
 23214  424 
         RewriteRuleTokenStream stream_MIN=new RewriteRuleTokenStream(adaptor,"token MIN");
 23215  438 
         RewriteRuleTokenStream stream_SUM=new RewriteRuleTokenStream(adaptor,"token SUM");
 23216  424 
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 23217  424 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 23218  424 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 23219  444 
         RewriteRuleSubtreeStream stream_string=new RewriteRuleSubtreeStream(adaptor,"rule string");
 23220  20 
         try {
 23221   
             // com\\googlecode\\sparkleg\\Sparql.g:649:5: ( COUNT '(' ( DISTINCT )? ( '*' | expression ) ')' -> ^( COUNT ( DISTINCT )* ( '*' )* ( expression )* ) | SUM '(' ( DISTINCT )? expression ')' -> ^( SUM ( DISTINCT )* expression ) | MIN '(' ( DISTINCT )? expression ')' -> ^( MIN ( DISTINCT )* expression ) | MAX '(' ( DISTINCT )? expression ')' -> ^( MAX ( DISTINCT )* expression ) | AVG '(' ( DISTINCT )? expression ')' -> ^( AVG ( DISTINCT )* expression ) | SAMPLE '(' ( DISTINCT )? expression ')' -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT '(' ( DISTINCT )? expression ( ';' SEPARATOR '=' string )? ')' -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) )
 23222  444 
             int alt137=7;
 23223  424 
             switch ( input.LA(1) ) {
 23224  20 
             case COUNT:
 23225   
                 {
 23226  136 
                 alt137=1;
 23227   
                 }
 23228  136 
                 break;
 23229   
             case SUM:
 23230   
                 {
 23231  48 
                 alt137=2;
 23232  34 
                 }
 23233  82 
                 break;
 23234   
             case MIN:
 23235   
                 {
 23236  56 
                 alt137=3;
 23237   
                 }
 23238  56 
                 break;
 23239   
             case MAX:
 23240   
                 {
 23241  40 
                 alt137=4;
 23242   
                 }
 23243  74 
                 break;
 23244  34 
             case AVG:
 23245   
                 {
 23246  130 
                 alt137=5;
 23247   
                 }
 23248  96 
                 break;
 23249   
             case SAMPLE:
 23250   
                 {
 23251  58 
                 alt137=6;
 23252  34 
                 }
 23253  24 
                 break;
 23254   
             case GROUP_CONCAT:
 23255   
                 {
 23256  24 
                 alt137=7;
 23257  34 
                 }
 23258  24 
                 break;
 23259   
             default:
 23260  0 
                 NoViableAltException nvae =
 23261   
                     new NoViableAltException("", 137, 0, input);
 23262   
 
 23263  34 
                 throw nvae;
 23264   
 
 23265   
             }
 23266  48 
 
 23267  438 
             switch (alt137) {
 23268   
                 case 1 :
 23269   
                     // com\\googlecode\\sparkleg\\Sparql.g:649:7: COUNT '(' ( DISTINCT )? ( '*' | expression ) ')'
 23270   
                     {
 23271  136 
                     COUNT626=(Token)match(input,COUNT,FOLLOW_COUNT_in_aggregate6646);
 23272  170 
                     stream_COUNT.add(COUNT626);
 23273   
 
 23274   
 
 23275  190 
                     char_literal627=(Token)match(input,209,FOLLOW_209_in_aggregate6648);
 23276  156 
                     stream_209.add(char_literal627);
 23277   
 
 23278   
 
 23279  34 
                     // com\\googlecode\\sparkleg\\Sparql.g:649:17: ( DISTINCT )?
 23280  136 
                     int alt128=2;
 23281  170 
                     switch ( input.LA(1) ) {
 23282   
                         case DISTINCT:
 23283   
                             {
 23284  0 
                             alt128=1;
 23285   
                             }
 23286   
                             break;
 23287  34 
                     }
 23288   
 
 23289  136 
                     switch (alt128) {
 23290  34 
                         case 1 :
 23291   
                             // com\\googlecode\\sparkleg\\Sparql.g:649:17: DISTINCT
 23292   
                             {
 23293  0 
                             DISTINCT628=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6650);
 23294  12 
                             stream_DISTINCT.add(DISTINCT628);
 23295  12 
 
 23296   
 
 23297   
                             }
 23298  12 
                             break;
 23299  12 
 
 23300   
                     }
 23301   
 
 23302   
 
 23303  12 
                     // com\\googlecode\\sparkleg\\Sparql.g:649:27: ( '*' | expression )
 23304  148 
                     int alt129=2;
 23305  136 
                     switch ( input.LA(1) ) {
 23306   
                     case ASTERISK:
 23307   
                         {
 23308  56 
                         alt129=1;
 23309   
                         }
 23310  56 
                         break;
 23311   
                     case ABS:
 23312  12 
                     case AVG:
 23313   
                     case BNODE:
 23314   
                     case BOUND:
 23315   
                     case CEIL:
 23316   
                     case COALESCE:
 23317   
                     case CONCAT:
 23318   
                     case CONTAINS:
 23319   
                     case COUNT:
 23320   
                     case DATATYPE:
 23321   
                     case DAY:
 23322   
                     case DECIMAL:
 23323   
                     case DECIMAL_NEGATIVE:
 23324   
                     case DECIMAL_POSITIVE:
 23325   
                     case DOUBLE:
 23326  12 
                     case DOUBLE_NEGATIVE:
 23327  12 
                     case DOUBLE_POSITIVE:
 23328   
                     case ENCODE_FOR_URI:
 23329  12 
                     case EXISTS:
 23330   
                     case FALSE:
 23331  12 
                     case FLOOR:
 23332   
                     case GROUP_CONCAT:
 23333  12 
                     case HOURS:
 23334  12 
                     case IF:
 23335   
                     case INTEGER:
 23336   
                     case INTEGER_NEGATIVE:
 23337   
                     case INTEGER_POSITIVE:
 23338   
                     case IRI:
 23339   
                     case IRI_REF:
 23340   
                     case ISBLANK:
 23341   
                     case ISIRI:
 23342   
                     case ISLITERAL:
 23343   
                     case ISNUMERIC:
 23344  12 
                     case ISURI:
 23345  12 
                     case LANG:
 23346   
                     case LANGMATCHES:
 23347  12 
                     case LCASE:
 23348   
                     case MAX:
 23349   
                     case MD5:
 23350   
                     case MIN:
 23351   
                     case MINUS:
 23352  12 
                     case MINUTES:
 23353  12 
                     case MONTH:
 23354   
                     case NEGATION:
 23355   
                     case NOT:
 23356   
                     case NOW:
 23357   
                     case PLUS:
 23358  12 
                     case PNAME_LN:
 23359   
                     case PNAME_NS:
 23360   
                     case RAND:
 23361   
                     case REGEX:
 23362   
                     case REPLACE:
 23363   
                     case ROUND:
 23364  12 
                     case SAMETERM:
 23365   
                     case SAMPLE:
 23366  12 
                     case SECONDS:
 23367   
                     case SHA1:
 23368  12 
                     case SHA256:
 23369   
                     case SHA384:
 23370   
                     case SHA512:
 23371   
                     case STR:
 23372   
                     case STRAFTER:
 23373   
                     case STRBEFORE:
 23374  12 
                     case STRDT:
 23375   
                     case STRENDS:
 23376   
                     case STRING_LITERAL1:
 23377  12 
                     case STRING_LITERAL2:
 23378   
                     case STRING_LITERAL_LONG1:
 23379   
                     case STRING_LITERAL_LONG2:
 23380   
                     case STRLANG:
 23381  14 
                     case STRLEN:
 23382  14 
                     case STRSTARTS:
 23383   
                     case SUBSTR:
 23384   
                     case SUM:
 23385  14 
                     case TIMEZONE:
 23386  14 
                     case TRUE:
 23387   
                     case TZ:
 23388   
                     case UCASE:
 23389   
                     case URI:
 23390  14 
                     case VAR1:
 23391  14 
                     case VAR2:
 23392   
                     case YEAR:
 23393   
                     case 209:
 23394   
                         {
 23395  80 
                         alt129=2;
 23396   
                         }
 23397  80 
                         break;
 23398   
                     default:
 23399  14 
                         NoViableAltException nvae =
 23400   
                             new NoViableAltException("", 129, 0, input);
 23401   
 
 23402  0 
                         throw nvae;
 23403   
 
 23404   
                     }
 23405   
 
 23406  136 
                     switch (alt129) {
 23407   
                         case 1 :
 23408   
                             // com\\googlecode\\sparkleg\\Sparql.g:649:28: '*'
 23409   
                             {
 23410  56 
                             char_literal629=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_aggregate6654);
 23411  56 
                             stream_ASTERISK.add(char_literal629);
 23412   
 
 23413  14 
 
 23414  14 
                             }
 23415  56 
                             break;
 23416  14 
                         case 2 :
 23417   
                             // com\\googlecode\\sparkleg\\Sparql.g:649:34: expression
 23418  14 
                             {
 23419  80 
                             pushFollow(FOLLOW_expression_in_aggregate6658);
 23420  94 
                             expression630=expression();
 23421  14 
 
 23422  80 
                             state._fsp--;
 23423   
 
 23424  80 
                             stream_expression.add(expression630.getTree());
 23425   
 
 23426   
                             }
 23427   
                             break;
 23428   
 
 23429   
                     }
 23430   
 
 23431  14 
 
 23432  150 
                     char_literal631=(Token)match(input,210,FOLLOW_210_in_aggregate6661);
 23433  136 
                     stream_210.add(char_literal631);
 23434  14 
 
 23435   
 
 23436   
                     // AST REWRITE
 23437   
                     // elements: COUNT, ASTERISK, DISTINCT, expression
 23438   
                     // token labels:
 23439  14 
                     // rule labels: retval
 23440  14 
                     // token list labels:
 23441   
                     // rule list labels:
 23442   
                     // wildcard labels:
 23443  136 
                     retval.tree = root_0;
 23444  136 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23445  14 
 
 23446  136 
                     root_0 = (Object)adaptor.nil();
 23447   
                     // 649:50: -> ^( COUNT ( DISTINCT )* ( '*' )* ( expression )* )
 23448   
                     {
 23449   
                         // com\\googlecode\\sparkleg\\Sparql.g:649:53: ^( COUNT ( DISTINCT )* ( '*' )* ( expression )* )
 23450   
                         {
 23451  150 
                         Object root_1 = (Object)adaptor.nil();
 23452  136 
                         root_1 = (Object)adaptor.becomeRoot(
 23453  14 
                         stream_COUNT.nextNode()
 23454   
                         , root_1);
 23455  14 
 
 23456   
                         // com\\googlecode\\sparkleg\\Sparql.g:649:61: ( DISTINCT )*
 23457  136 
                         while ( stream_DISTINCT.hasNext() ) {
 23458  0 
                             adaptor.addChild(root_1,
 23459   
                             stream_DISTINCT.nextNode()
 23460   
                             );
 23461  14 
 
 23462   
                         }
 23463  136 
                         stream_DISTINCT.reset();
 23464  14 
 
 23465   
                         // com\\googlecode\\sparkleg\\Sparql.g:649:71: ( '*' )*
 23466  192 
                         while ( stream_ASTERISK.hasNext() ) {
 23467  56 
                             adaptor.addChild(root_1,
 23468  10 
                             stream_ASTERISK.nextNode()
 23469  10 
                             );
 23470   
 
 23471   
                         }
 23472  146 
                         stream_ASTERISK.reset();
 23473  10 
 
 23474   
                         // com\\googlecode\\sparkleg\\Sparql.g:649:76: ( expression )*
 23475  216 
                         while ( stream_expression.hasNext() ) {
 23476  80 
                             adaptor.addChild(root_1, stream_expression.nextTree());
 23477  10 
 
 23478  10 
                         }
 23479  136 
                         stream_expression.reset();
 23480   
 
 23481  136 
                         adaptor.addChild(root_0, root_1);
 23482   
                         }
 23483   
 
 23484   
                     }
 23485   
 
 23486  10 
 
 23487  136 
                     retval.tree = root_0;
 23488   
 
 23489   
                     }
 23490  136 
                     break;
 23491   
                 case 2 :
 23492   
                     // com\\googlecode\\sparkleg\\Sparql.g:650:7: SUM '(' ( DISTINCT )? expression ')'
 23493   
                     {
 23494  48 
                     SUM632=(Token)match(input,SUM,FOLLOW_SUM_in_aggregate6684);
 23495  48 
                     stream_SUM.add(SUM632);
 23496   
 
 23497   
 
 23498  48 
                     char_literal633=(Token)match(input,209,FOLLOW_209_in_aggregate6686);
 23499  48 
                     stream_209.add(char_literal633);
 23500  10 
 
 23501  10 
 
 23502   
                     // com\\googlecode\\sparkleg\\Sparql.g:650:15: ( DISTINCT )?
 23503  58 
                     int alt130=2;
 23504  48 
                     switch ( input.LA(1) ) {
 23505  10 
                         case DISTINCT:
 23506   
                             {
 23507  10 
                             alt130=1;
 23508  10 
                             }
 23509   
                             break;
 23510   
                     }
 23511   
 
 23512  48 
                     switch (alt130) {
 23513   
                         case 1 :
 23514   
                             // com\\googlecode\\sparkleg\\Sparql.g:650:15: DISTINCT
 23515   
                             {
 23516  0 
                             DISTINCT634=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6688);
 23517  0 
                             stream_DISTINCT.add(DISTINCT634);
 23518  10 
 
 23519  10 
 
 23520   
                             }
 23521  10 
                             break;
 23522   
 
 23523   
                     }
 23524   
 
 23525   
 
 23526  58 
                     pushFollow(FOLLOW_expression_in_aggregate6691);
 23527  58 
                     expression635=expression();
 23528   
 
 23529  48 
                     state._fsp--;
 23530   
 
 23531  48 
                     stream_expression.add(expression635.getTree());
 23532  10 
 
 23533  48 
                     char_literal636=(Token)match(input,210,FOLLOW_210_in_aggregate6693);
 23534  48 
                     stream_210.add(char_literal636);
 23535   
 
 23536   
 
 23537   
                     // AST REWRITE
 23538  10 
                     // elements: SUM, expression, DISTINCT
 23539   
                     // token labels:
 23540  10 
                     // rule labels: retval
 23541   
                     // token list labels:
 23542  10 
                     // rule list labels:
 23543   
                     // wildcard labels:
 23544  48 
                     retval.tree = root_0;
 23545  48 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23546   
 
 23547  48 
                     root_0 = (Object)adaptor.nil();
 23548  10 
                     // 650:40: -> ^( SUM ( DISTINCT )* expression )
 23549   
                     {
 23550   
                         // com\\googlecode\\sparkleg\\Sparql.g:650:43: ^( SUM ( DISTINCT )* expression )
 23551  10 
                         {
 23552  48 
                         Object root_1 = (Object)adaptor.nil();
 23553  48 
                         root_1 = (Object)adaptor.becomeRoot(
 23554   
                         stream_SUM.nextNode()
 23555  24 
                         , root_1);
 23556  24 
 
 23557   
                         // com\\googlecode\\sparkleg\\Sparql.g:650:49: ( DISTINCT )*
 23558  48 
                         while ( stream_DISTINCT.hasNext() ) {
 23559  24 
                             adaptor.addChild(root_1,
 23560  24 
                             stream_DISTINCT.nextNode()
 23561   
                             );
 23562   
 
 23563   
                         }
 23564  72 
                         stream_DISTINCT.reset();
 23565  24 
 
 23566  48 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23567   
 
 23568  48 
                         adaptor.addChild(root_0, root_1);
 23569   
                         }
 23570   
 
 23571   
                     }
 23572   
 
 23573  24 
 
 23574  48 
                     retval.tree = root_0;
 23575   
 
 23576   
                     }
 23577  48 
                     break;
 23578   
                 case 3 :
 23579   
                     // com\\googlecode\\sparkleg\\Sparql.g:651:7: MIN '(' ( DISTINCT )? expression ')'
 23580   
                     {
 23581  56 
                     MIN637=(Token)match(input,MIN,FOLLOW_MIN_in_aggregate6712);
 23582  56 
                     stream_MIN.add(MIN637);
 23583   
 
 23584   
 
 23585  56 
                     char_literal638=(Token)match(input,209,FOLLOW_209_in_aggregate6714);
 23586  56 
                     stream_209.add(char_literal638);
 23587  24 
 
 23588  24 
 
 23589   
                     // com\\googlecode\\sparkleg\\Sparql.g:651:15: ( DISTINCT )?
 23590  80 
                     int alt131=2;
 23591  56 
                     switch ( input.LA(1) ) {
 23592  24 
                         case DISTINCT:
 23593   
                             {
 23594  24 
                             alt131=1;
 23595  24 
                             }
 23596   
                             break;
 23597   
                     }
 23598   
 
 23599  56 
                     switch (alt131) {
 23600   
                         case 1 :
 23601   
                             // com\\googlecode\\sparkleg\\Sparql.g:651:15: DISTINCT
 23602   
                             {
 23603  0 
                             DISTINCT639=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6716);
 23604  0 
                             stream_DISTINCT.add(DISTINCT639);
 23605  24 
 
 23606  24 
 
 23607   
                             }
 23608  24 
                             break;
 23609   
 
 23610   
                     }
 23611   
 
 23612   
 
 23613  80 
                     pushFollow(FOLLOW_expression_in_aggregate6719);
 23614  80 
                     expression640=expression();
 23615   
 
 23616  56 
                     state._fsp--;
 23617   
 
 23618  56 
                     stream_expression.add(expression640.getTree());
 23619  24 
 
 23620  56 
                     char_literal641=(Token)match(input,210,FOLLOW_210_in_aggregate6721);
 23621  56 
                     stream_210.add(char_literal641);
 23622   
 
 23623   
 
 23624   
                     // AST REWRITE
 23625  24 
                     // elements: MIN, expression, DISTINCT
 23626   
                     // token labels:
 23627  24 
                     // rule labels: retval
 23628   
                     // token list labels:
 23629  24 
                     // rule list labels:
 23630   
                     // wildcard labels:
 23631  56 
                     retval.tree = root_0;
 23632  56 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23633   
 
 23634  56 
                     root_0 = (Object)adaptor.nil();
 23635  24 
                     // 651:40: -> ^( MIN ( DISTINCT )* expression )
 23636   
                     {
 23637   
                         // com\\googlecode\\sparkleg\\Sparql.g:651:43: ^( MIN ( DISTINCT )* expression )
 23638  24 
                         {
 23639  56 
                         Object root_1 = (Object)adaptor.nil();
 23640  56 
                         root_1 = (Object)adaptor.becomeRoot(
 23641   
                         stream_MIN.nextNode()
 23642  6 
                         , root_1);
 23643  6 
 
 23644   
                         // com\\googlecode\\sparkleg\\Sparql.g:651:49: ( DISTINCT )*
 23645  56 
                         while ( stream_DISTINCT.hasNext() ) {
 23646  6 
                             adaptor.addChild(root_1,
 23647  6 
                             stream_DISTINCT.nextNode()
 23648   
                             );
 23649   
 
 23650   
                         }
 23651  62 
                         stream_DISTINCT.reset();
 23652  6 
 
 23653  56 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23654   
 
 23655  56 
                         adaptor.addChild(root_0, root_1);
 23656   
                         }
 23657   
 
 23658   
                     }
 23659   
 
 23660  6 
 
 23661  56 
                     retval.tree = root_0;
 23662   
 
 23663   
                     }
 23664  56 
                     break;
 23665   
                 case 4 :
 23666   
                     // com\\googlecode\\sparkleg\\Sparql.g:652:7: MAX '(' ( DISTINCT )? expression ')'
 23667   
                     {
 23668  40 
                     MAX642=(Token)match(input,MAX,FOLLOW_MAX_in_aggregate6740);
 23669  40 
                     stream_MAX.add(MAX642);
 23670   
 
 23671   
 
 23672  40 
                     char_literal643=(Token)match(input,209,FOLLOW_209_in_aggregate6742);
 23673  40 
                     stream_209.add(char_literal643);
 23674  6 
 
 23675  6 
 
 23676   
                     // com\\googlecode\\sparkleg\\Sparql.g:652:15: ( DISTINCT )?
 23677  46 
                     int alt132=2;
 23678  40 
                     switch ( input.LA(1) ) {
 23679  6 
                         case DISTINCT:
 23680   
                             {
 23681  6 
                             alt132=1;
 23682  6 
                             }
 23683   
                             break;
 23684   
                     }
 23685   
 
 23686  40 
                     switch (alt132) {
 23687   
                         case 1 :
 23688   
                             // com\\googlecode\\sparkleg\\Sparql.g:652:15: DISTINCT
 23689   
                             {
 23690  0 
                             DISTINCT644=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6744);
 23691  0 
                             stream_DISTINCT.add(DISTINCT644);
 23692  6 
 
 23693  6 
 
 23694   
                             }
 23695  6 
                             break;
 23696   
 
 23697   
                     }
 23698   
 
 23699   
 
 23700  46 
                     pushFollow(FOLLOW_expression_in_aggregate6747);
 23701  46 
                     expression645=expression();
 23702   
 
 23703  40 
                     state._fsp--;
 23704   
 
 23705  40 
                     stream_expression.add(expression645.getTree());
 23706  6 
 
 23707  40 
                     char_literal646=(Token)match(input,210,FOLLOW_210_in_aggregate6749);
 23708  40 
                     stream_210.add(char_literal646);
 23709   
 
 23710   
 
 23711   
                     // AST REWRITE
 23712  6 
                     // elements: expression, DISTINCT, MAX
 23713   
                     // token labels:
 23714  6 
                     // rule labels: retval
 23715   
                     // token list labels:
 23716  6 
                     // rule list labels:
 23717   
                     // wildcard labels:
 23718  40 
                     retval.tree = root_0;
 23719  40 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23720   
 
 23721  40 
                     root_0 = (Object)adaptor.nil();
 23722  6 
                     // 652:40: -> ^( MAX ( DISTINCT )* expression )
 23723   
                     {
 23724   
                         // com\\googlecode\\sparkleg\\Sparql.g:652:43: ^( MAX ( DISTINCT )* expression )
 23725  6 
                         {
 23726  40 
                         Object root_1 = (Object)adaptor.nil();
 23727  40 
                         root_1 = (Object)adaptor.becomeRoot(
 23728   
                         stream_MAX.nextNode()
 23729  6 
                         , root_1);
 23730  6 
 
 23731   
                         // com\\googlecode\\sparkleg\\Sparql.g:652:49: ( DISTINCT )*
 23732  40 
                         while ( stream_DISTINCT.hasNext() ) {
 23733  6 
                             adaptor.addChild(root_1,
 23734  6 
                             stream_DISTINCT.nextNode()
 23735   
                             );
 23736   
 
 23737   
                         }
 23738  46 
                         stream_DISTINCT.reset();
 23739  6 
 
 23740  40 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23741   
 
 23742  40 
                         adaptor.addChild(root_0, root_1);
 23743   
                         }
 23744   
 
 23745   
                     }
 23746   
 
 23747  6 
 
 23748  40 
                     retval.tree = root_0;
 23749   
 
 23750   
                     }
 23751  40 
                     break;
 23752   
                 case 5 :
 23753   
                     // com\\googlecode\\sparkleg\\Sparql.g:653:7: AVG '(' ( DISTINCT )? expression ')'
 23754   
                     {
 23755  96 
                     AVG647=(Token)match(input,AVG,FOLLOW_AVG_in_aggregate6768);
 23756  96 
                     stream_AVG.add(AVG647);
 23757   
 
 23758   
 
 23759  96 
                     char_literal648=(Token)match(input,209,FOLLOW_209_in_aggregate6770);
 23760  96 
                     stream_209.add(char_literal648);
 23761  6 
 
 23762  6 
 
 23763   
                     // com\\googlecode\\sparkleg\\Sparql.g:653:15: ( DISTINCT )?
 23764  102 
                     int alt133=2;
 23765  96 
                     switch ( input.LA(1) ) {
 23766  6 
                         case DISTINCT:
 23767   
                             {
 23768  0 
                             alt133=1;
 23769  6 
                             }
 23770  6 
                             break;
 23771   
                     }
 23772   
 
 23773  98 
                     switch (alt133) {
 23774   
                         case 1 :
 23775   
                             // com\\googlecode\\sparkleg\\Sparql.g:653:15: DISTINCT
 23776   
                             {
 23777  0 
                             DISTINCT649=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6772);
 23778  6 
                             stream_DISTINCT.add(DISTINCT649);
 23779   
 
 23780   
 
 23781   
                             }
 23782  2 
                             break;
 23783  2 
 
 23784   
                     }
 23785   
 
 23786  2 
 
 23787  98 
                     pushFollow(FOLLOW_expression_in_aggregate6775);
 23788  96 
                     expression650=expression();
 23789   
 
 23790  98 
                     state._fsp--;
 23791  2 
 
 23792  96 
                     stream_expression.add(expression650.getTree());
 23793   
 
 23794  98 
                     char_literal651=(Token)match(input,210,FOLLOW_210_in_aggregate6777);
 23795  98 
                     stream_210.add(char_literal651);
 23796   
 
 23797  2 
 
 23798   
                     // AST REWRITE
 23799  2 
                     // elements: AVG, expression, DISTINCT
 23800   
                     // token labels:
 23801   
                     // rule labels: retval
 23802   
                     // token list labels:
 23803   
                     // rule list labels:
 23804   
                     // wildcard labels:
 23805  96 
                     retval.tree = root_0;
 23806  96 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23807  6 
 
 23808  102 
                     root_0 = (Object)adaptor.nil();
 23809   
                     // 653:40: -> ^( AVG ( DISTINCT )* expression )
 23810   
                     {
 23811   
                         // com\\googlecode\\sparkleg\\Sparql.g:653:43: ^( AVG ( DISTINCT )* expression )
 23812   
                         {
 23813  96 
                         Object root_1 = (Object)adaptor.nil();
 23814  96 
                         root_1 = (Object)adaptor.becomeRoot(
 23815   
                         stream_AVG.nextNode()
 23816   
                         , root_1);
 23817   
 
 23818  6 
                         // com\\googlecode\\sparkleg\\Sparql.g:653:49: ( DISTINCT )*
 23819  102 
                         while ( stream_DISTINCT.hasNext() ) {
 23820  0 
                             adaptor.addChild(root_1,
 23821  6 
                             stream_DISTINCT.nextNode()
 23822   
                             );
 23823   
 
 23824   
                         }
 23825  96 
                         stream_DISTINCT.reset();
 23826  6 
 
 23827  102 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23828   
 
 23829  96 
                         adaptor.addChild(root_0, root_1);
 23830   
                         }
 23831   
 
 23832  6 
                     }
 23833   
 
 23834   
 
 23835  96 
                     retval.tree = root_0;
 23836   
 
 23837   
                     }
 23838  102 
                     break;
 23839   
                 case 6 :
 23840  6 
                     // com\\googlecode\\sparkleg\\Sparql.g:654:7: SAMPLE '(' ( DISTINCT )? expression ')'
 23841   
                     {
 23842  24 
                     SAMPLE652=(Token)match(input,SAMPLE,FOLLOW_SAMPLE_in_aggregate6796);
 23843  32 
                     stream_SAMPLE.add(SAMPLE652);
 23844  2 
 
 23845   
 
 23846  24 
                     char_literal653=(Token)match(input,209,FOLLOW_209_in_aggregate6798);
 23847  30 
                     stream_209.add(char_literal653);
 23848   
 
 23849  6 
 
 23850   
                     // com\\googlecode\\sparkleg\\Sparql.g:654:18: ( DISTINCT )?
 23851  24 
                     int alt134=2;
 23852  24 
                     switch ( input.LA(1) ) {
 23853   
                         case DISTINCT:
 23854   
                             {
 23855  6 
                             alt134=1;
 23856   
                             }
 23857   
                             break;
 23858   
                     }
 23859   
 
 23860  24 
                     switch (alt134) {
 23861  106 
                         case 1 :
 23862   
                             // com\\googlecode\\sparkleg\\Sparql.g:654:18: DISTINCT
 23863   
                             {
 23864  106 
                             DISTINCT654=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6800);
 23865  106 
                             stream_DISTINCT.add(DISTINCT654);
 23866   
 
 23867   
 
 23868   
                             }
 23869   
                             break;
 23870   
 
 23871   
                     }
 23872   
 
 23873   
 
 23874  24 
                     pushFollow(FOLLOW_expression_in_aggregate6803);
 23875  24 
                     expression655=expression();
 23876   
 
 23877  130 
                     state._fsp--;
 23878  106 
 
 23879  24 
                     stream_expression.add(expression655.getTree());
 23880   
 
 23881  24 
                     char_literal656=(Token)match(input,210,FOLLOW_210_in_aggregate6805);
 23882  24 
                     stream_210.add(char_literal656);
 23883  176 
 
 23884   
 
 23885  176 
                     // AST REWRITE
 23886   
                     // elements: expression, DISTINCT, SAMPLE
 23887   
                     // token labels:
 23888   
                     // rule labels: retval
 23889   
                     // token list labels:
 23890   
                     // rule list labels:
 23891   
                     // wildcard labels:
 23892  200 
                     retval.tree = root_0;
 23893  200 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23894   
 
 23895  24 
                     root_0 = (Object)adaptor.nil();
 23896  176 
                     // 654:43: -> ^( SAMPLE ( DISTINCT )? expression )
 23897   
                     {
 23898  176 
                         // com\\googlecode\\sparkleg\\Sparql.g:654:46: ^( SAMPLE ( DISTINCT )? expression )
 23899   
                         {
 23900  200 
                         Object root_1 = (Object)adaptor.nil();
 23901  24 
                         root_1 = (Object)adaptor.becomeRoot(
 23902   
                         stream_SAMPLE.nextNode()
 23903  176 
                         , root_1);
 23904  176 
 
 23905   
                         // com\\googlecode\\sparkleg\\Sparql.g:654:55: ( DISTINCT )?
 23906  24 
                         if ( stream_DISTINCT.hasNext() ) {
 23907  0 
                             adaptor.addChild(root_1,
 23908   
                             stream_DISTINCT.nextNode()
 23909  176 
                             );
 23910  176 
 
 23911   
                         }
 23912  200 
                         stream_DISTINCT.reset();
 23913   
 
 23914  200 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23915   
 
 23916  24 
                         adaptor.addChild(root_0, root_1);
 23917  176 
                         }
 23918  176 
 
 23919   
                     }
 23920   
 
 23921  48 
 
 23922  24 
                     retval.tree = root_0;
 23923   
 
 23924   
                     }
 23925  24 
                     break;
 23926  176 
                 case 7 :
 23927   
                     // com\\googlecode\\sparkleg\\Sparql.g:655:7: GROUP_CONCAT '(' ( DISTINCT )? expression ( ';' SEPARATOR '=' string )? ')'
 23928   
                     {
 23929  24 
                     GROUP_CONCAT657=(Token)match(input,GROUP_CONCAT,FOLLOW_GROUP_CONCAT_in_aggregate6824);
 23930  72 
                     stream_GROUP_CONCAT.add(GROUP_CONCAT657);
 23931  48 
 
 23932   
 
 23933  72 
                     char_literal658=(Token)match(input,209,FOLLOW_209_in_aggregate6826);
 23934  24 
                     stream_209.add(char_literal658);
 23935  48 
 
 23936   
 
 23937   
                     // com\\googlecode\\sparkleg\\Sparql.g:655:24: ( DISTINCT )?
 23938  24 
                     int alt135=2;
 23939  24 
                     switch ( input.LA(1) ) {
 23940   
                         case DISTINCT:
 23941   
                             {
 23942  0 
                             alt135=1;
 23943   
                             }
 23944   
                             break;
 23945   
                     }
 23946   
 
 23947  24 
                     switch (alt135) {
 23948   
                         case 1 :
 23949   
                             // com\\googlecode\\sparkleg\\Sparql.g:655:24: DISTINCT
 23950  176 
                             {
 23951  176 
                             DISTINCT659=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6828);
 23952  0 
                             stream_DISTINCT.add(DISTINCT659);
 23953  176 
 
 23954   
 
 23955   
                             }
 23956   
                             break;
 23957   
 
 23958  176 
                     }
 23959  176 
 
 23960   
 
 23961  24 
                     pushFollow(FOLLOW_expression_in_aggregate6831);
 23962  24 
                     expression660=expression();
 23963  176 
 
 23964  24 
                     state._fsp--;
 23965   
 
 23966  200 
                     stream_expression.add(expression660.getTree());
 23967   
 
 23968   
                     // com\\googlecode\\sparkleg\\Sparql.g:655:45: ( ';' SEPARATOR '=' string )?
 23969  72 
                     int alt136=2;
 23970  72 
                     switch ( input.LA(1) ) {
 23971   
                         case 212:
 23972   
                             {
 23973  8 
                             alt136=1;
 23974  48 
                             }
 23975   
                             break;
 23976  48 
                     }
 23977   
 
 23978  24 
                     switch (alt136) {
 23979   
                         case 1 :
 23980  176 
                             // com\\googlecode\\sparkleg\\Sparql.g:655:46: ';' SEPARATOR '=' string
 23981   
                             {
 23982  184 
                             char_literal661=(Token)match(input,212,FOLLOW_212_in_aggregate6834);
 23983  8 
                             stream_212.add(char_literal661);
 23984   
 
 23985   
 
 23986  8 
                             SEPARATOR662=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_aggregate6836);
 23987  8 
                             stream_SEPARATOR.add(SEPARATOR662);
 23988  176 
 
 23989   
 
 23990  8 
                             char_literal663=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_aggregate6838);
 23991  8 
                             stream_EQUAL.add(char_literal663);
 23992  176 
 
 23993   
 
 23994  8 
                             pushFollow(FOLLOW_string_in_aggregate6840);
 23995  184 
                             string664=string();
 23996  176 
 
 23997  8 
                             state._fsp--;
 23998   
 
 23999  8 
                             stream_string.add(string664.getTree());
 24000   
 
 24001   
                             }
 24002   
                             break;
 24003   
 
 24004   
                     }
 24005   
 
 24006   
 
 24007  24 
                     char_literal665=(Token)match(input,210,FOLLOW_210_in_aggregate6844);
 24008  200 
                     stream_210.add(char_literal665);
 24009  176 
 
 24010   
 
 24011   
                     // AST REWRITE
 24012   
                     // elements: string, GROUP_CONCAT, expression, DISTINCT
 24013   
                     // token labels:
 24014  378 
                     // rule labels: retval
 24015   
                     // token list labels:
 24016  378 
                     // rule list labels:
 24017   
                     // wildcard labels:
 24018  24 
                     retval.tree = root_0;
 24019  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 24020   
 
 24021  24 
                     root_0 = (Object)adaptor.nil();
 24022   
                     // 655:77: -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 24023  378 
                     {
 24024  378 
                         // com\\googlecode\\sparkleg\\Sparql.g:655:80: ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 24025   
                         {
 24026  24 
                         Object root_1 = (Object)adaptor.nil();
 24027  402 
                         root_1 = (Object)adaptor.becomeRoot(
 24028   
                         stream_GROUP_CONCAT.nextNode()
 24029  378 
                         , root_1);
 24030  378 
 
 24031  378 
                         // com\\googlecode\\sparkleg\\Sparql.g:655:95: ( DISTINCT )*
 24032  24 
                         while ( stream_DISTINCT.hasNext() ) {
 24033  378 
                             adaptor.addChild(root_1,
 24034   
                             stream_DISTINCT.nextNode()
 24035   
                             );
 24036  378 
 
 24037  378 
                         }
 24038  24 
                         stream_DISTINCT.reset();
 24039   
 
 24040  24 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 24041   
 
 24042   
                         // com\\googlecode\\sparkleg\\Sparql.g:655:116: ( string )*
 24043  410 
                         while ( stream_string.hasNext() ) {
 24044  8 
                             adaptor.addChild(root_1, stream_string.nextTree());
 24045   
 
 24046  378 
                         }
 24047  402 
                         stream_string.reset();
 24048   
 
 24049  402 
                         adaptor.addChild(root_0, root_1);
 24050   
                         }
 24051  378 
 
 24052   
                     }
 24053   
 
 24054  378 
 
 24055  402 
                     retval.tree = root_0;
 24056   
 
 24057   
                     }
 24058  10 
                     break;
 24059   
 
 24060  10 
             }
 24061  424 
             retval.stop = input.LT(-1);
 24062   
 
 24063  38 
 
 24064  424 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24065  424 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24066   
 
 24067   
         }
 24068  378 
         catch (RecognitionException re) {
 24069  0 
             reportError(re);
 24070  0 
             recover(input,re);
 24071  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24072  10 
 
 24073  10 
         }
 24074   
 
 24075  0 
         finally {
 24076  10 
                 // do for sure before leaving
 24077  424 
         }
 24078  424 
         return retval;
 24079   
     }
 24080  10 
     // $ANTLR end "aggregate"
 24081   
 
 24082   
 
 24083  704 
     public static class iriRefOrFunction_return extends ParserRuleReturnScope {
 24084   
         Object tree;
 24085  704 
         public Object getTree() { return tree; }
 24086   
     };
 24087  38 
 
 24088  38 
 
 24089   
     // $ANTLR start "iriRefOrFunction"
 24090   
     // com\\googlecode\\sparkleg\\Sparql.g:658:1: iriRefOrFunction : iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) ;
 24091  38 
     public final SparqlParser.iriRefOrFunction_return iriRefOrFunction() throws RecognitionException {
 24092  704 
         SparqlParser.iriRefOrFunction_return retval = new SparqlParser.iriRefOrFunction_return();
 24093  704 
         retval.start = input.LT(1);
 24094  38 
 
 24095  38 
 
 24096  704 
         Object root_0 = null;
 24097  38 
 
 24098  704 
         SparqlParser.iriRef_return iriRef666 =null;
 24099  38 
 
 24100  704 
         SparqlParser.argList_return argList667 =null;
 24101   
 
 24102   
 
 24103  704 
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 24104  704 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 24105   
         try {
 24106   
             // com\\googlecode\\sparkleg\\Sparql.g:659:5: ( iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) )
 24107   
             // com\\googlecode\\sparkleg\\Sparql.g:659:7: iriRef ( argList )?
 24108   
             {
 24109  704 
             pushFollow(FOLLOW_iriRef_in_iriRefOrFunction6879);
 24110  704 
             iriRef666=iriRef();
 24111   
 
 24112  1082 
             state._fsp--;
 24113   
 
 24114  704 
             stream_iriRef.add(iriRef666.getTree());
 24115  378 
 
 24116  378 
             // com\\googlecode\\sparkleg\\Sparql.g:659:14: ( argList )?
 24117  704 
             int alt138=2;
 24118  704 
             switch ( input.LA(1) ) {
 24119   
                 case 209:
 24120   
                     {
 24121  384 
                     alt138=1;
 24122   
                     }
 24123   
                     break;
 24124   
             }
 24125   
 
 24126  704 
             switch (alt138) {
 24127   
                 case 1 :
 24128  378 
                     // com\\googlecode\\sparkleg\\Sparql.g:659:14: argList
 24129  378 
                     {
 24130  384 
                     pushFollow(FOLLOW_argList_in_iriRefOrFunction6881);
 24131  384 
                     argList667=argList();
 24132   
 
 24133  384 
                     state._fsp--;
 24134  282 
 
 24135  384 
                     stream_argList.add(argList667.getTree());
 24136  282 
 
 24137   
                     }
 24138   
                     break;
 24139   
 
 24140   
             }
 24141   
 
 24142   
 
 24143  282 
             // AST REWRITE
 24144  282 
             // elements: argList, iriRef
 24145   
             // token labels:
 24146   
             // rule labels: retval
 24147  282 
             // token list labels:
 24148   
             // rule list labels:
 24149  282 
             // wildcard labels:
 24150  704 
             retval.tree = root_0;
 24151  986 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 24152   
 
 24153  986 
             root_0 = (Object)adaptor.nil();
 24154   
             // 659:23: -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 24155   
             {
 24156   
                 // com\\googlecode\\sparkleg\\Sparql.g:659:26: ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 24157   
                 {
 24158  704 
                 Object root_1 = (Object)adaptor.nil();
 24159  986 
                 root_1 = (Object)adaptor.becomeRoot(
 24160  282 
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 24161   
                 , root_1);
 24162   
 
 24163  704 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 24164   
 
 24165  256 
                 // com\\googlecode\\sparkleg\\Sparql.g:659:44: ( ^( ARG_LIST argList ) )?
 24166  704 
                 if ( stream_argList.hasNext() ) {
 24167  256 
                     // com\\googlecode\\sparkleg\\Sparql.g:659:44: ^( ARG_LIST argList )
 24168   
                     {
 24169  384 
                     Object root_2 = (Object)adaptor.nil();
 24170  384 
                     root_2 = (Object)adaptor.becomeRoot(
 24171   
                     (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 24172  10 
                     , root_2);
 24173   
 
 24174  394 
                     adaptor.addChild(root_2, stream_argList.nextTree());
 24175   
 
 24176  384 
                     adaptor.addChild(root_1, root_2);
 24177   
                     }
 24178   
 
 24179  16 
                 }
 24180  704 
                 stream_argList.reset();
 24181  16 
 
 24182  704 
                 adaptor.addChild(root_0, root_1);
 24183   
                 }
 24184   
 
 24185   
             }
 24186   
 
 24187   
 
 24188  704 
             retval.tree = root_0;
 24189   
 
 24190  282 
             }
 24191   
 
 24192  704 
             retval.stop = input.LT(-1);
 24193   
 
 24194  256 
 
 24195  704 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24196  704 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24197  256 
 
 24198  256 
         }
 24199  0 
         catch (RecognitionException re) {
 24200  256 
             reportError(re);
 24201  0 
             recover(input,re);
 24202  256 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24203   
 
 24204   
         }
 24205  256 
 
 24206  0 
         finally {
 24207   
                 // do for sure before leaving
 24208  704 
         }
 24209  714 
         return retval;
 24210   
     }
 24211   
     // $ANTLR end "iriRefOrFunction"
 24212  10 
 
 24213  10 
 
 24214  1512 
     public static class rdfLiteral_return extends ParserRuleReturnScope {
 24215  10 
         Object tree;
 24216  1512 
         public Object getTree() { return tree; }
 24217  10 
     };
 24218   
 
 24219   
 
 24220  10 
     // $ANTLR start "rdfLiteral"
 24221   
     // com\\googlecode\\sparkleg\\Sparql.g:662:1: rdfLiteral : string ( LANGTAG | ( '^^' iriRef ) )? -> ^( RDFLITERAL string ( LANGTAG )* ( iriRef )* ) ;
 24222   
     public final SparqlParser.rdfLiteral_return rdfLiteral() throws RecognitionException {
 24223  1512 
         SparqlParser.rdfLiteral_return retval = new SparqlParser.rdfLiteral_return();
 24224  1528 
         retval.start = input.LT(1);
 24225   
 
 24226   
 
 24227  1528 
         Object root_0 = null;
 24228  16 
 
 24229  1512 
         Token LANGTAG669=null;
 24230  1528 
         Token string_literal670=null;
 24231  1512 
         SparqlParser.string_return string668 =null;
 24232  16 
 
 24233  1512 
         SparqlParser.iriRef_return iriRef671 =null;
 24234   
 
 24235   
 
 24236  1512 
         Object LANGTAG669_tree=null;
 24237  1512 
         Object string_literal670_tree=null;
 24238  1794 
         RewriteRuleTokenStream stream_215=new RewriteRuleTokenStream(adaptor,"token 215");
 24239  1512 
         RewriteRuleTokenStream stream_LANGTAG=new RewriteRuleTokenStream(adaptor,"token LANGTAG");
 24240  1512 
         RewriteRuleSubtreeStream stream_string=new RewriteRuleSubtreeStream(adaptor,"rule string");
 24241  1794 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 24242  282 
         try {
 24243   
             // com\\googlecode\\sparkleg\\Sparql.g:663:5: ( string ( LANGTAG | ( '^^' iriRef ) )? -> ^( RDFLITERAL string ( LANGTAG )* ( iriRef )* ) )
 24244   
             // com\\googlecode\\sparkleg\\Sparql.g:663:7: string ( LANGTAG | ( '^^' iriRef ) )?
 24245   
             {
 24246  1512 
             pushFollow(FOLLOW_string_in_rdfLiteral6914);
 24247  1512 
             string668=string();
 24248   
 
 24249  1512 
             state._fsp--;
 24250   
 
 24251  1512 
             stream_string.add(string668.getTree());
 24252   
 
 24253   
             // com\\googlecode\\sparkleg\\Sparql.g:663:14: ( LANGTAG | ( '^^' iriRef ) )?
 24254  1794 
             int alt139=3;
 24255  1794 
             switch ( input.LA(1) ) {
 24256   
                 case LANGTAG:
 24257   
                     {
 24258  40 
                     alt139=1;
 24259   
                     }
 24260  40 
                     break;
 24261   
                 case 215:
 24262  256 
                     {
 24263  152 
                     alt139=2;
 24264   
                     }
 24265   
                     break;
 24266   
             }
 24267   
 
 24268  1512 
             switch (alt139) {
 24269  256 
                 case 1 :
 24270  256 
                     // com\\googlecode\\sparkleg\\Sparql.g:663:15: LANGTAG
 24271   
                     {
 24272  40 
                     LANGTAG669=(Token)match(input,LANGTAG,FOLLOW_LANGTAG_in_rdfLiteral6917);
 24273  296 
                     stream_LANGTAG.add(LANGTAG669);
 24274   
 
 24275  256 
 
 24276   
                     }
 24277  296 
                     break;
 24278   
                 case 2 :
 24279   
                     // com\\googlecode\\sparkleg\\Sparql.g:663:25: ( '^^' iriRef )
 24280   
                     {
 24281   
                     // com\\googlecode\\sparkleg\\Sparql.g:663:25: ( '^^' iriRef )
 24282   
                     // com\\googlecode\\sparkleg\\Sparql.g:663:26: '^^' iriRef
 24283  256 
                     {
 24284  152 
                     string_literal670=(Token)match(input,215,FOLLOW_215_in_rdfLiteral6922);
 24285  152 
                     stream_215.add(string_literal670);
 24286  256 
 
 24287   
 
 24288  408 
                     pushFollow(FOLLOW_iriRef_in_rdfLiteral6924);
 24289  408 
                     iriRef671=iriRef();
 24290  256 
 
 24291  152 
                     state._fsp--;
 24292   
 
 24293  408 
                     stream_iriRef.add(iriRef671.getTree());
 24294   
 
 24295   
                     }
 24296   
 
 24297   
 
 24298   
                     }
 24299   
                     break;
 24300   
 
 24301   
             }
 24302   
 
 24303  256 
 
 24304   
             // AST REWRITE
 24305   
             // elements: string, iriRef, LANGTAG
 24306  256 
             // token labels:
 24307  256 
             // rule labels: retval
 24308   
             // token list labels:
 24309   
             // rule list labels:
 24310   
             // wildcard labels:
 24311  1512 
             retval.tree = root_0;
 24312  1512 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 24313   
 
 24314  1512 
             root_0 = (Object)adaptor.nil();
 24315   
             // 663:41: -> ^( RDFLITERAL string ( LANGTAG )* ( iriRef )* )
 24316   
             {
 24317   
                 // com\\googlecode\\sparkleg\\Sparql.g:663:44: ^( RDFLITERAL string ( LANGTAG )* ( iriRef )* )
 24318   
                 {
 24319  1768 
                 Object root_1 = (Object)adaptor.nil();
 24320  1768 
                 root_1 = (Object)adaptor.becomeRoot(
 24321   
                 (Object)adaptor.create(RDFLITERAL, "RDFLITERAL")
 24322   
                 , root_1);
 24323   
 
 24324  1512 
                 adaptor.addChild(root_1, stream_string.nextTree());
 24325  50 
 
 24326   
                 // com\\googlecode\\sparkleg\\Sparql.g:663:64: ( LANGTAG )*
 24327  1552 
                 while ( stream_LANGTAG.hasNext() ) {
 24328  40 
                     adaptor.addChild(root_1,
 24329   
                     stream_LANGTAG.nextNode()
 24330   
                     );
 24331   
 
 24332   
                 }
 24333  1512 
                 stream_LANGTAG.reset();
 24334  50 
 
 24335  50 
                 // com\\googlecode\\sparkleg\\Sparql.g:663:73: ( iriRef )*
 24336  1664 
                 while ( stream_iriRef.hasNext() ) {
 24337  152 
                     adaptor.addChild(root_1, stream_iriRef.nextTree());
 24338  50 
 
 24339   
                 }
 24340  1562 
                 stream_iriRef.reset();
 24341   
 
 24342  1562 
                 adaptor.addChild(root_0, root_1);
 24343   
                 }
 24344   
 
 24345   
             }
 24346   
 
 24347   
 
 24348  1562 
             retval.tree = root_0;
 24349   
 
 24350   
             }
 24351  50 
 
 24352  1512 
             retval.stop = input.LT(-1);
 24353  50 
 
 24354  50 
 
 24355  1562 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24356  1512 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24357   
 
 24358  50 
         }
 24359  0 
         catch (RecognitionException re) {
 24360  0 
             reportError(re);
 24361  0 
             recover(input,re);
 24362  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24363   
 
 24364   
         }
 24365   
 
 24366  0 
         finally {
 24367   
                 // do for sure before leaving
 24368  1562 
         }
 24369  1512 
         return retval;
 24370   
     }
 24371  50 
     // $ANTLR end "rdfLiteral"
 24372  50 
 
 24373   
 
 24374  1182 
     public static class numericLiteral_return extends ParserRuleReturnScope {
 24375   
         Object tree;
 24376  1182 
         public Object getTree() { return tree; }
 24377   
     };
 24378   
 
 24379   
 
 24380   
     // $ANTLR start "numericLiteral"
 24381   
     // com\\googlecode\\sparkleg\\Sparql.g:666:1: numericLiteral : ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative );
 24382   
     public final SparqlParser.numericLiteral_return numericLiteral() throws RecognitionException {
 24383  1182 
         SparqlParser.numericLiteral_return retval = new SparqlParser.numericLiteral_return();
 24384  1232 
         retval.start = input.LT(1);
 24385  50 
 
 24386   
 
 24387  1182 
         Object root_0 = null;
 24388   
 
 24389  1182 
         SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned672 =null;
 24390  16 
 
 24391  1182 
         SparqlParser.numericLiteralPositive_return numericLiteralPositive673 =null;
 24392  16 
 
 24393  1182 
         SparqlParser.numericLiteralNegative_return numericLiteralNegative674 =null;
 24394   
 
 24395   
 
 24396   
 
 24397   
         try {
 24398   
             // com\\googlecode\\sparkleg\\Sparql.g:667:5: ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative )
 24399  1198 
             int alt140=3;
 24400  1198 
             switch ( input.LA(1) ) {
 24401   
             case DECIMAL:
 24402   
             case DOUBLE:
 24403  16 
             case INTEGER:
 24404   
                 {
 24405  1034 
                 alt140=1;
 24406   
                 }
 24407  1034 
                 break;
 24408   
             case DECIMAL_POSITIVE:
 24409   
             case DOUBLE_POSITIVE:
 24410   
             case INTEGER_POSITIVE:
 24411   
                 {
 24412  100 
                 alt140=2;
 24413  16 
                 }
 24414  100 
                 break;
 24415   
             case DECIMAL_NEGATIVE:
 24416  16 
             case DOUBLE_NEGATIVE:
 24417   
             case INTEGER_NEGATIVE:
 24418  16 
                 {
 24419  80 
                 alt140=3;
 24420  16 
                 }
 24421  64 
                 break;
 24422   
             default:
 24423  16 
                 NoViableAltException nvae =
 24424   
                     new NoViableAltException("", 140, 0, input);
 24425   
 
 24426  0 
                 throw nvae;
 24427   
 
 24428   
             }
 24429   
 
 24430  1182 
             switch (alt140) {
 24431   
                 case 1 :
 24432   
                     // com\\googlecode\\sparkleg\\Sparql.g:667:7: numericLiteralUnsigned
 24433  16 
                     {
 24434  1018 
                     root_0 = (Object)adaptor.nil();
 24435   
 
 24436  16 
 
 24437  1034 
                     pushFollow(FOLLOW_numericLiteralUnsigned_in_numericLiteral6958);
 24438  1018 
                     numericLiteralUnsigned672=numericLiteralUnsigned();
 24439   
 
 24440  1018 
                     state._fsp--;
 24441   
 
 24442  1018 
                     adaptor.addChild(root_0, numericLiteralUnsigned672.getTree());
 24443   
 
 24444   
                     }
 24445  1018 
                     break;
 24446   
                 case 2 :
 24447   
                     // com\\googlecode\\sparkleg\\Sparql.g:668:7: numericLiteralPositive
 24448   
                     {
 24449  116 
                     root_0 = (Object)adaptor.nil();
 24450  16 
 
 24451   
 
 24452  100 
                     pushFollow(FOLLOW_numericLiteralPositive_in_numericLiteral6966);
 24453  100 
                     numericLiteralPositive673=numericLiteralPositive();
 24454   
 
 24455  100 
                     state._fsp--;
 24456   
 
 24457  100 
                     adaptor.addChild(root_0, numericLiteralPositive673.getTree());
 24458   
 
 24459   
                     }
 24460  100 
                     break;
 24461   
                 case 3 :
 24462   
                     // com\\googlecode\\sparkleg\\Sparql.g:669:7: numericLiteralNegative
 24463   
                     {
 24464  80 
                     root_0 = (Object)adaptor.nil();
 24465  16 
 
 24466   
 
 24467  64 
                     pushFollow(FOLLOW_numericLiteralNegative_in_numericLiteral6974);
 24468  80 
                     numericLiteralNegative674=numericLiteralNegative();
 24469   
 
 24470  80 
                     state._fsp--;
 24471   
 
 24472  80 
                     adaptor.addChild(root_0, numericLiteralNegative674.getTree());
 24473   
 
 24474   
                     }
 24475   
                     break;
 24476   
 
 24477   
             }
 24478  1198 
             retval.stop = input.LT(-1);
 24479   
 
 24480   
 
 24481  1198 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24482  1182 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24483  16 
 
 24484  16 
         }
 24485  16 
         catch (RecognitionException re) {
 24486  0 
             reportError(re);
 24487  0 
             recover(input,re);
 24488  16 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24489   
 
 24490   
         }
 24491   
 
 24492  0 
         finally {
 24493   
                 // do for sure before leaving
 24494  1182 
         }
 24495  1182 
         return retval;
 24496   
     }
 24497   
     // $ANTLR end "numericLiteral"
 24498  16 
 
 24499   
 
 24500  1018 
     public static class numericLiteralUnsigned_return extends ParserRuleReturnScope {
 24501  16 
         Object tree;
 24502  16 
         public Object getTree() { return tree; }
 24503   
     };
 24504   
 
 24505   
 
 24506   
     // $ANTLR start "numericLiteralUnsigned"
 24507   
     // com\\googlecode\\sparkleg\\Sparql.g:672:1: numericLiteralUnsigned : ( INTEGER | DECIMAL | DOUBLE );
 24508   
     public final SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned() throws RecognitionException {
 24509  1018 
         SparqlParser.numericLiteralUnsigned_return retval = new SparqlParser.numericLiteralUnsigned_return();
 24510  1018 
         retval.start = input.LT(1);
 24511   
 
 24512   
 
 24513  1018 
         Object root_0 = null;
 24514  16 
 
 24515  1034 
         Token set675=null;
 24516   
 
 24517  1018 
         Object set675_tree=null;
 24518   
 
 24519   
         try {
 24520  380 
             // com\\googlecode\\sparkleg\\Sparql.g:673:5: ( INTEGER | DECIMAL | DOUBLE )
 24521   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24522  380 
             {
 24523  1018 
             root_0 = (Object)adaptor.nil();
 24524   
 
 24525   
 
 24526  1018 
             set675=(Token)input.LT(1);
 24527   
 
 24528  1018 
             if ( input.LA(1)==DECIMAL||input.LA(1)==DOUBLE||input.LA(1)==INTEGER ) {
 24529  1398 
                 input.consume();
 24530  1398 
                 adaptor.addChild(root_0,
 24531   
                 (Object)adaptor.create(set675)
 24532   
                 );
 24533  1398 
                 state.errorRecovery=false;
 24534   
             }
 24535  380 
             else {
 24536  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24537  380 
                 throw mse;
 24538   
             }
 24539   
 
 24540   
 
 24541   
             }
 24542   
 
 24543  1398 
             retval.stop = input.LT(-1);
 24544   
 
 24545   
 
 24546  1398 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24547  1018 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24548  380 
 
 24549  380 
         }
 24550  380 
         catch (RecognitionException re) {
 24551  0 
             reportError(re);
 24552  0 
             recover(input,re);
 24553  380 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24554   
 
 24555   
         }
 24556   
 
 24557  0 
         finally {
 24558   
                 // do for sure before leaving
 24559  1018 
         }
 24560  1018 
         return retval;
 24561   
     }
 24562   
     // $ANTLR end "numericLiteralUnsigned"
 24563  380 
 
 24564   
 
 24565  200 
     public static class numericLiteralPositive_return extends ParserRuleReturnScope {
 24566  380 
         Object tree;
 24567  380 
         public Object getTree() { return tree; }
 24568   
     };
 24569   
 
 24570   
 
 24571   
     // $ANTLR start "numericLiteralPositive"
 24572   
     // com\\googlecode\\sparkleg\\Sparql.g:678:1: numericLiteralPositive : ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE );
 24573   
     public final SparqlParser.numericLiteralPositive_return numericLiteralPositive() throws RecognitionException {
 24574  200 
         SparqlParser.numericLiteralPositive_return retval = new SparqlParser.numericLiteralPositive_return();
 24575  200 
         retval.start = input.LT(1);
 24576   
 
 24577   
 
 24578  200 
         Object root_0 = null;
 24579  380 
 
 24580  580 
         Token set676=null;
 24581   
 
 24582  200 
         Object set676_tree=null;
 24583   
 
 24584   
         try {
 24585  4350 
             // com\\googlecode\\sparkleg\\Sparql.g:679:5: ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE )
 24586   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24587  4350 
             {
 24588  200 
             root_0 = (Object)adaptor.nil();
 24589   
 
 24590   
 
 24591  200 
             set676=(Token)input.LT(1);
 24592   
 
 24593  200 
             if ( input.LA(1)==DECIMAL_POSITIVE||input.LA(1)==DOUBLE_POSITIVE||input.LA(1)==INTEGER_POSITIVE ) {
 24594  4550 
                 input.consume();
 24595  4550 
                 adaptor.addChild(root_0,
 24596   
                 (Object)adaptor.create(set676)
 24597   
                 );
 24598  4550 
                 state.errorRecovery=false;
 24599   
             }
 24600  4350 
             else {
 24601  4350 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24602  0 
                 throw mse;
 24603   
             }
 24604  4350 
 
 24605   
 
 24606   
             }
 24607   
 
 24608  4550 
             retval.stop = input.LT(-1);
 24609  4350 
 
 24610   
 
 24611  200 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24612  672 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24613   
 
 24614  472 
         }
 24615  0 
         catch (RecognitionException re) {
 24616  0 
             reportError(re);
 24617  0 
             recover(input,re);
 24618  3878 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24619   
 
 24620  3878 
         }
 24621   
 
 24622  0 
         finally {
 24623   
                 // do for sure before leaving
 24624  200 
         }
 24625  200 
         return retval;
 24626   
     }
 24627   
     // $ANTLR end "numericLiteralPositive"
 24628   
 
 24629  4350 
 
 24630  64 
     public static class numericLiteralNegative_return extends ParserRuleReturnScope {
 24631   
         Object tree;
 24632  64 
         public Object getTree() { return tree; }
 24633  472 
     };
 24634   
 
 24635   
 
 24636  472 
     // $ANTLR start "numericLiteralNegative"
 24637  472 
     // com\\googlecode\\sparkleg\\Sparql.g:684:1: numericLiteralNegative : ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE );
 24638   
     public final SparqlParser.numericLiteralNegative_return numericLiteralNegative() throws RecognitionException {
 24639  64 
         SparqlParser.numericLiteralNegative_return retval = new SparqlParser.numericLiteralNegative_return();
 24640  536 
         retval.start = input.LT(1);
 24641   
 
 24642   
 
 24643  64 
         Object root_0 = null;
 24644  472 
 
 24645  64 
         Token set677=null;
 24646   
 
 24647  64 
         Object set677_tree=null;
 24648  3878 
 
 24649   
         try {
 24650   
             // com\\googlecode\\sparkleg\\Sparql.g:685:5: ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE )
 24651  3878 
             // com\\googlecode\\sparkleg\\Sparql.g:
 24652  3878 
             {
 24653  64 
             root_0 = (Object)adaptor.nil();
 24654  3878 
 
 24655   
 
 24656  3942 
             set677=(Token)input.LT(1);
 24657   
 
 24658  64 
             if ( input.LA(1)==DECIMAL_NEGATIVE||input.LA(1)==DOUBLE_NEGATIVE||input.LA(1)==INTEGER_NEGATIVE ) {
 24659  64 
                 input.consume();
 24660  64 
                 adaptor.addChild(root_0,
 24661   
                 (Object)adaptor.create(set677)
 24662  4350 
                 );
 24663  64 
                 state.errorRecovery=false;
 24664   
             }
 24665  4350 
             else {
 24666  4350 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24667  0 
                 throw mse;
 24668   
             }
 24669   
 
 24670   
 
 24671   
             }
 24672   
 
 24673  64 
             retval.stop = input.LT(-1);
 24674   
 
 24675   
 
 24676  64 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24677  64 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24678  4350 
 
 24679  4350 
         }
 24680  0 
         catch (RecognitionException re) {
 24681  0 
             reportError(re);
 24682  0 
             recover(input,re);
 24683  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24684  3878 
 
 24685   
         }
 24686  3878 
 
 24687  0 
         finally {
 24688   
                 // do for sure before leaving
 24689  64 
         }
 24690  64 
         return retval;
 24691   
     }
 24692   
     // $ANTLR end "numericLiteralNegative"
 24693  3878 
 
 24694  3878 
 
 24695  64 
     public static class booleanLiteral_return extends ParserRuleReturnScope {
 24696   
         Object tree;
 24697  3878 
         public Object getTree() { return tree; }
 24698   
     };
 24699  3878 
 
 24700   
 
 24701  3878 
     // $ANTLR start "booleanLiteral"
 24702   
     // com\\googlecode\\sparkleg\\Sparql.g:690:1: booleanLiteral : ( TRUE | FALSE );
 24703   
     public final SparqlParser.booleanLiteral_return booleanLiteral() throws RecognitionException {
 24704  64 
         SparqlParser.booleanLiteral_return retval = new SparqlParser.booleanLiteral_return();
 24705  64 
         retval.start = input.LT(1);
 24706   
 
 24707  3878 
 
 24708  64 
         Object root_0 = null;
 24709   
 
 24710  3942 
         Token set678=null;
 24711   
 
 24712  3942 
         Object set678_tree=null;
 24713  3878 
 
 24714  3878 
         try {
 24715   
             // com\\googlecode\\sparkleg\\Sparql.g:691:5: ( TRUE | FALSE )
 24716   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24717  3878 
             {
 24718  64 
             root_0 = (Object)adaptor.nil();
 24719   
 
 24720   
 
 24721  64 
             set678=(Token)input.LT(1);
 24722   
 
 24723  64 
             if ( input.LA(1)==FALSE||input.LA(1)==TRUE ) {
 24724  64 
                 input.consume();
 24725  64 
                 adaptor.addChild(root_0,
 24726   
                 (Object)adaptor.create(set678)
 24727  3878 
                 );
 24728  64 
                 state.errorRecovery=false;
 24729   
             }
 24730  3878 
             else {
 24731  3878 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24732  0 
                 throw mse;
 24733   
             }
 24734   
 
 24735   
 
 24736   
             }
 24737   
 
 24738  64 
             retval.stop = input.LT(-1);
 24739   
 
 24740   
 
 24741  64 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24742  64 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24743  3878 
 
 24744  3878 
         }
 24745  0 
         catch (RecognitionException re) {
 24746  0 
             reportError(re);
 24747  0 
             recover(input,re);
 24748  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24749  204 
 
 24750   
         }
 24751  204 
 
 24752  0 
         finally {
 24753   
                 // do for sure before leaving
 24754  64 
         }
 24755  64 
         return retval;
 24756   
     }
 24757   
     // $ANTLR end "booleanLiteral"
 24758  204 
 
 24759  204 
 
 24760  1520 
     public static class string_return extends ParserRuleReturnScope {
 24761   
         Object tree;
 24762  1520 
         public Object getTree() { return tree; }
 24763   
     };
 24764  204 
 
 24765  204 
 
 24766   
     // $ANTLR start "string"
 24767   
     // com\\googlecode\\sparkleg\\Sparql.g:695:1: string : ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 );
 24768  204 
     public final SparqlParser.string_return string() throws RecognitionException {
 24769  1520 
         SparqlParser.string_return retval = new SparqlParser.string_return();
 24770  1520 
         retval.start = input.LT(1);
 24771   
 
 24772  204 
 
 24773  1724 
         Object root_0 = null;
 24774   
 
 24775  1520 
         Token set679=null;
 24776  116 
 
 24777  1520 
         Object set679_tree=null;
 24778  116 
 
 24779   
         try {
 24780   
             // com\\googlecode\\sparkleg\\Sparql.g:696:5: ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 )
 24781  88 
             // com\\googlecode\\sparkleg\\Sparql.g:
 24782   
             {
 24783  1608 
             root_0 = (Object)adaptor.nil();
 24784   
 
 24785   
 
 24786  1520 
             set679=(Token)input.LT(1);
 24787   
 
 24788  1520 
             if ( (input.LA(1) >= STRING_LITERAL1 && input.LA(1) <= STRING_LITERAL_LONG2) ) {
 24789  1520 
                 input.consume();
 24790  1520 
                 adaptor.addChild(root_0,
 24791   
                 (Object)adaptor.create(set679)
 24792  204 
                 );
 24793  1520 
                 state.errorRecovery=false;
 24794   
             }
 24795   
             else {
 24796  116 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24797  0 
                 throw mse;
 24798   
             }
 24799  116 
 
 24800  116 
 
 24801   
             }
 24802   
 
 24803  1636 
             retval.stop = input.LT(-1);
 24804   
 
 24805   
 
 24806  1520 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24807  1636 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24808   
 
 24809   
         }
 24810  0 
         catch (RecognitionException re) {
 24811  88 
             reportError(re);
 24812  0 
             recover(input,re);
 24813  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24814  88 
 
 24815  88 
         }
 24816   
 
 24817  88 
         finally {
 24818   
                 // do for sure before leaving
 24819  1608 
         }
 24820  1520 
         return retval;
 24821   
     }
 24822   
     // $ANTLR end "string"
 24823   
 
 24824   
 
 24825  17241 
     public static class iriRef_return extends ParserRuleReturnScope {
 24826   
         Object tree;
 24827  17241 
         public Object getTree() { return tree; }
 24828  204 
     };
 24829  204 
 
 24830   
 
 24831   
     // $ANTLR start "iriRef"
 24832   
     // com\\googlecode\\sparkleg\\Sparql.g:702:1: iriRef : ( IRI_REF | prefixedName );
 24833   
     public final SparqlParser.iriRef_return iriRef() throws RecognitionException {
 24834  17241 
         SparqlParser.iriRef_return retval = new SparqlParser.iriRef_return();
 24835  17241 
         retval.start = input.LT(1);
 24836   
 
 24837   
 
 24838  17241 
         Object root_0 = null;
 24839   
 
 24840  17241 
         Token IRI_REF680=null;
 24841  17445 
         SparqlParser.prefixedName_return prefixedName681 =null;
 24842  204 
 
 24843   
 
 24844  17241 
         Object IRI_REF680_tree=null;
 24845   
 
 24846   
         try {
 24847  88 
             // com\\googlecode\\sparkleg\\Sparql.g:703:5: ( IRI_REF | prefixedName )
 24848  17241 
             int alt141=2;
 24849  17241 
             switch ( input.LA(1) ) {
 24850   
             case IRI_REF:
 24851   
                 {
 24852  1864 
                 alt141=1;
 24853   
                 }
 24854  1864 
                 break;
 24855   
             case PNAME_LN:
 24856  88 
             case PNAME_NS:
 24857  88 
                 {
 24858  15377 
                 alt141=2;
 24859   
                 }
 24860  15465 
                 break;
 24861   
             default:
 24862  88 
                 NoViableAltException nvae =
 24863  88 
                     new NoViableAltException("", 141, 0, input);
 24864   
 
 24865  88 
                 throw nvae;
 24866  88 
 
 24867   
             }
 24868   
 
 24869  17241 
             switch (alt141) {
 24870   
                 case 1 :
 24871   
                     // com\\googlecode\\sparkleg\\Sparql.g:703:7: IRI_REF
 24872  88 
                     {
 24873  1864 
                     root_0 = (Object)adaptor.nil();
 24874   
 
 24875  88 
 
 24876  1952 
                     IRI_REF680=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_iriRef7157);
 24877  1864 
                     IRI_REF680_tree =
 24878   
                     (Object)adaptor.create(IRI_REF680)
 24879  88 
                     ;
 24880  1864 
                     adaptor.addChild(root_0, IRI_REF680_tree);
 24881   
 
 24882  88 
 
 24883  88 
                     }
 24884  1864 
                     break;
 24885   
                 case 2 :
 24886  88 
                     // com\\googlecode\\sparkleg\\Sparql.g:704:7: prefixedName
 24887   
                     {
 24888  15377 
                     root_0 = (Object)adaptor.nil();
 24889   
 
 24890   
 
 24891  15465 
                     pushFollow(FOLLOW_prefixedName_in_iriRef7165);
 24892  15377 
                     prefixedName681=prefixedName();
 24893   
 
 24894  15465 
                     state._fsp--;
 24895  88 
 
 24896  15377 
                     adaptor.addChild(root_0, prefixedName681.getTree());
 24897   
 
 24898   
                     }
 24899   
                     break;
 24900   
 
 24901   
             }
 24902  17241 
             retval.stop = input.LT(-1);
 24903   
 
 24904   
 
 24905  17241 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24906  17241 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24907  88 
 
 24908  88 
         }
 24909  0 
         catch (RecognitionException re) {
 24910  0 
             reportError(re);
 24911  0 
             recover(input,re);
 24912  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24913   
 
 24914   
         }
 24915  1958 
 
 24916  0 
         finally {
 24917   
                 // do for sure before leaving
 24918  17241 
         }
 24919  17241 
         return retval;
 24920   
     }
 24921   
     // $ANTLR end "iriRef"
 24922   
 
 24923   
 
 24924  15377 
     public static class prefixedName_return extends ParserRuleReturnScope {
 24925   
         Object tree;
 24926  15377 
         public Object getTree() { return tree; }
 24927   
     };
 24928  2 
 
 24929   
 
 24930   
     // $ANTLR start "prefixedName"
 24931   
     // com\\googlecode\\sparkleg\\Sparql.g:707:1: prefixedName : ( PNAME_LN | PNAME_NS );
 24932   
     public final SparqlParser.prefixedName_return prefixedName() throws RecognitionException {
 24933  15377 
         SparqlParser.prefixedName_return retval = new SparqlParser.prefixedName_return();
 24934  15377 
         retval.start = input.LT(1);
 24935   
 
 24936   
 
 24937  15377 
         Object root_0 = null;
 24938   
 
 24939  15377 
         Token set682=null;
 24940   
 
 24941  15377 
         Object set682_tree=null;
 24942   
 
 24943   
         try {
 24944   
             // com\\googlecode\\sparkleg\\Sparql.g:708:5: ( PNAME_LN | PNAME_NS )
 24945   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24946   
             {
 24947  15377 
             root_0 = (Object)adaptor.nil();
 24948  2 
 
 24949  2 
 
 24950  15379 
             set682=(Token)input.LT(1);
 24951  2 
 
 24952  15379 
             if ( (input.LA(1) >= PNAME_LN && input.LA(1) <= PNAME_NS) ) {
 24953  15379 
                 input.consume();
 24954  15377 
                 adaptor.addChild(root_0,
 24955   
                 (Object)adaptor.create(set682)
 24956   
                 );
 24957  15379 
                 state.errorRecovery=false;
 24958  2 
             }
 24959  18 
             else {
 24960  16 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24961  0 
                 throw mse;
 24962   
             }
 24963   
 
 24964   
 
 24965   
             }
 24966  1958 
 
 24967  15377 
             retval.stop = input.LT(-1);
 24968  1958 
 
 24969  1958 
 
 24970  15377 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24971  15377 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24972  1958 
 
 24973  1958 
         }
 24974  0 
         catch (RecognitionException re) {
 24975  0 
             reportError(re);
 24976  0 
             recover(input,re);
 24977  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24978   
 
 24979   
         }
 24980   
 
 24981  0 
         finally {
 24982   
                 // do for sure before leaving
 24983  15379 
         }
 24984  15379 
         return retval;
 24985  2 
     }
 24986  2 
     // $ANTLR end "prefixedName"
 24987  2 
 
 24988  2 
 
 24989  2 
     public static class blankNode_return extends ParserRuleReturnScope {
 24990  2 
         Object tree;
 24991  2 
         public Object getTree() { return tree; }
 24992  2 
     };
 24993  2 
 
 24994  2 
 
 24995  2 
     // $ANTLR start "blankNode"
 24996  2 
     // com\\googlecode\\sparkleg\\Sparql.g:712:1: blankNode : ( BLANK_NODE_LABEL | anon );
 24997  2 
     public final SparqlParser.blankNode_return blankNode() throws RecognitionException {
 24998  782 
         SparqlParser.blankNode_return retval = new SparqlParser.blankNode_return();
 24999  782 
         retval.start = input.LT(1);
 25000  2 
 
 25001  2 
 
 25002  782 
         Object root_0 = null;
 25003  2 
 
 25004  782 
         Token BLANK_NODE_LABEL683=null;
 25005  782 
         SparqlParser.anon_return anon684 =null;
 25006  2 
 
 25007  2 
 
 25008  782 
         Object BLANK_NODE_LABEL683_tree=null;
 25009  2 
 
 25010  2 
         try {
 25011  2 
             // com\\googlecode\\sparkleg\\Sparql.g:713:5: ( BLANK_NODE_LABEL | anon )
 25012  782 
             int alt142=2;
 25013  782 
             switch ( input.LA(1) ) {
 25014  2 
             case BLANK_NODE_LABEL:
 25015  2 
                 {
 25016  442 
                 alt142=1;
 25017  2 
                 }
 25018  442 
                 break;
 25019  2 
             case 213:
 25020  2 
                 {
 25021  342 
                 alt142=2;
 25022  2 
                 }
 25023  342 
                 break;
 25024  2 
             default:
 25025  2 
                 NoViableAltException nvae =
 25026  2 
                     new NoViableAltException("", 142, 0, input);
 25027  2 
 
 25028  2 
                 throw nvae;
 25029  2 
 
 25030  2 
             }
 25031  2 
 
 25032  782 
             switch (alt142) {
 25033  2 
                 case 1 :
 25034  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:713:7: BLANK_NODE_LABEL
 25035  2 
                     {
 25036  442 
                     root_0 = (Object)adaptor.nil();
 25037  2 
 
 25038  2 
 
 25039  442 
                     BLANK_NODE_LABEL683=(Token)match(input,BLANK_NODE_LABEL,FOLLOW_BLANK_NODE_LABEL_in_blankNode7207);
 25040  442 
                     BLANK_NODE_LABEL683_tree =
 25041  2 
                     (Object)adaptor.create(BLANK_NODE_LABEL683)
 25042  2 
                     ;
 25043  442 
                     adaptor.addChild(root_0, BLANK_NODE_LABEL683_tree);
 25044  2 
 
 25045  2 
 
 25046  2 
                     }
 25047  442 
                     break;
 25048  2 
                 case 2 :
 25049  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:714:7: anon
 25050  2 
                     {
 25051  342 
                     root_0 = (Object)adaptor.nil();
 25052  2 
 
 25053  2 
 
 25054  342 
                     pushFollow(FOLLOW_anon_in_blankNode7215);
 25055  342 
                     anon684=anon();
 25056  2 
 
 25057  342 
                     state._fsp--;
 25058  2 
 
 25059  342 
                     adaptor.addChild(root_0, anon684.getTree());
 25060  2 
 
 25061  2 
                     }
 25062  2 
                     break;
 25063  2 
 
 25064  2 
             }
 25065  782 
             retval.stop = input.LT(-1);
 25066  2 
 
 25067  2 
 
 25068  782 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 25069  782 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 25070  2 
 
 25071  2 
         }
 25072  2 
         catch (RecognitionException re) {
 25073  2 
             reportError(re);
 25074  2 
             recover(input,re);
 25075  2 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 25076  2 
 
 25077  2 
         }
 25078  2 
 
 25079  2 
         finally {
 25080  2 
                 // do for sure before leaving
 25081  782 
         }
 25082  782 
         return retval;
 25083  2 
     }
 25084  2 
     // $ANTLR end "blankNode"
 25085  2 
 
 25086  2 
 
 25087  2 
     public static class anon_return extends ParserRuleReturnScope {
 25088  2 
         Object tree;
 25089  2 
         public Object getTree() { return tree; }
 25090  2 
     };
 25091  2 
 
 25092  2 
 
 25093  2 
     // $ANTLR start "anon"
 25094  2 
     // com\\googlecode\\sparkleg\\Sparql.g:717:1: anon : '[' ']' -> ANON ;
 25095  2 
     public final SparqlParser.anon_return anon() throws RecognitionException {
 25096  342 
         SparqlParser.anon_return retval = new SparqlParser.anon_return();
 25097  342 
         retval.start = input.LT(1);
 25098  2 
 
 25099  2 
 
 25100  342 
         Object root_0 = null;
 25101  2 
 
 25102  342 
         Token char_literal685=null;
 25103  342 
         Token char_literal686=null;
 25104  2 
 
 25105  342 
         Object char_literal685_tree=null;
 25106  342 
         Object char_literal686_tree=null;
 25107  342 
         RewriteRuleTokenStream stream_213=new RewriteRuleTokenStream(adaptor,"token 213");
 25108  342 
         RewriteRuleTokenStream stream_214=new RewriteRuleTokenStream(adaptor,"token 214");
 25109  2 
 
 25110  2 
         try {
 25111  2 
             // com\\googlecode\\sparkleg\\Sparql.g:718:5: ( '[' ']' -> ANON )
 25112  2 
             // com\\googlecode\\sparkleg\\Sparql.g:718:7: '[' ']'
 25113  2 
             {
 25114  342 
             char_literal685=(Token)match(input,213,FOLLOW_213_in_anon7232);
 25115  342 
             stream_213.add(char_literal685);
 25116  2 
 
 25117  2 
 
 25118  342 
             char_literal686=(Token)match(input,214,FOLLOW_214_in_anon7234);
 25119  342 
             stream_214.add(char_literal686);
 25120  2 
 
 25121  2 
 
 25122  2 
             // AST REWRITE
 25123  2 
             // elements:
 25124  2 
             // token labels:
 25125  2 
             // rule labels: retval
 25126  2 
             // token list labels:
 25127  2 
             // rule list labels:
 25128  2 
             // wildcard labels:
 25129  342 
             retval.tree = root_0;
 25130  342 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 25131  2 
 
 25132  342 
             root_0 = (Object)adaptor.nil();
 25133  2 
             // 718:15: -> ANON
 25134  2 
             {
 25135  342 
                 adaptor.addChild(root_0,
 25136  2 
                 (Object)adaptor.create(ANON, "ANON")
 25137  2 
                 );
 25138  2 
 
 25139  2 
             }
 25140  2 
 
 25141  2 
 
 25142  342 
             retval.tree = root_0;
 25143  2 
 
 25144  2 
             }
 25145  2 
 
 25146  342 
             retval.stop = input.LT(-1);
 25147  2 
 
 25148  2 
 
 25149  342 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 25150  342 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 25151  2 
 
 25152  2 
         }
 25153  2 
         catch (RecognitionException re) {
 25154  2 
             reportError(re);
 25155  2 
             recover(input,re);
 25156  2 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 25157  2 
 
 25158  2 
         }
 25159  2 
 
 25160  2 
         finally {
 25161  2 
                 // do for sure before leaving
 25162  342 
         }
 25163  342 
         return retval;
 25164  2 
     }
 25165  2 
     // $ANTLR end "anon"
 25166  2 
 
 25167  2 
     // Delegated rules
 25168  2 
 
 25169  2 
 
 25170  7642 
     protected DFA4 dfa4 = new DFA4(this);
 25171  2 
     static final String DFA4_eotS =
 25172  2 
         "\10\uffff";
 25173  2 
     static final String DFA4_eofS =
 25174  2 
         "\10\uffff";
 25175  2 
     static final String DFA4_minS =
 25176  2 
         "\1\6\1\131\1\u0089\2\uffff\1\6\1\131\1\6";
 25177  2 
     static final String DFA4_maxS =
 25178  2 
         "\1\u00ce\1\131\1\u0089\2\uffff\1\u00ce\1\131\1\u00ce";
 25179  2 
     static final String DFA4_acceptS =
 25180  2 
         "\3\uffff\1\1\1\2\3\uffff";
 25181  2 
     static final String DFA4_specialS =
 25182  2 
         "\10\uffff}>";
 25183  7 
     static final String[] DFA4_transitionS = {
 25184  2 
             "\1\4\7\uffff\1\3\2\uffff\1\1\12\uffff\1\4\4\uffff\1\3\2\uffff"+
 25185  2 
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\31\uffff"+
 25186  2 
             "\1\4\24\uffff\1\4\10\uffff\1\4\40\uffff\1\2\14\uffff\1\3\57"+
 25187  2 
             "\uffff\1\4",
 25188  2 
             "\1\5",
 25189  2 
             "\1\6",
 25190  2 
             "",
 25191  2 
             "",
 25192  2 
             "\1\4\7\uffff\1\3\2\uffff\1\1\12\uffff\1\4\4\uffff\1\3\2\uffff"+
 25193  2 
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\31\uffff"+
 25194  2 
             "\1\4\24\uffff\1\4\10\uffff\1\4\40\uffff\1\2\14\uffff\1\3\57"+
 25195  2 
             "\uffff\1\4",
 25196  2 
             "\1\7",
 25197  2 
             "\1\4\7\uffff\1\3\2\uffff\1\1\12\uffff\1\4\4\uffff\1\3\2\uffff"+
 25198  2 
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\31\uffff"+
 25199  2 
             "\1\4\24\uffff\1\4\10\uffff\1\4\40\uffff\1\2\14\uffff\1\3\57"+
 25200  2 
             "\uffff\1\4"
 25201  2 
     };
 25202  2 
 
 25203  7 
     static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
 25204  7 
     static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
 25205  7 
     static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
 25206  7 
     static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
 25207  7 
     static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
 25208  7 
     static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
 25209  2 
     static final short[][] DFA4_transition;
 25210  2 
 
 25211  2 
     static {
 25212  7 
         int numStates = DFA4_transitionS.length;
 25213  7 
         DFA4_transition = new short[numStates][];
 25214  47 
         for (int i=0; i<numStates; i++) {
 25215  42 
             DFA4_transition[i] = DFA.unpackEncodedString(DFA4_transitionS[i]);
 25216  2 
         }
 25217  2 
     }
 25218  2 
 
 25219  2 
     class DFA4 extends DFA {
 25220  2 
 
 25221  2 
         public DFA4(BaseRecognizer recognizer) {
 25222  2 
             this.recognizer = recognizer;
 25223  2 
             this.decisionNumber = 4;
 25224  2 
             this.eot = DFA4_eot;
 25225  2 
             this.eof = DFA4_eof;
 25226  2 
             this.min = DFA4_min;
 25227  2 
             this.max = DFA4_max;
 25228  2 
             this.accept = DFA4_accept;
 25229  2 
             this.special = DFA4_special;
 25230  2 
             this.transition = DFA4_transition;
 25231  2 
         }
 25232  2 
         public String getDescription() {
 25233  2 
             return "98:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( ';' ( update )? )* EOF -> ^( UPDATE ( update )+ ) );";
 25234  2 
         }
 25235  2 
     }
 25236  2 
 
 25237  2 
 
 25238  7 
     public static final BitSet FOLLOW_prologue_in_query251 = new BitSet(new long[]{0x0001000200004000L,0x0000000000000000L,0x0000000040000000L});
 25239  7 
     public static final BitSet FOLLOW_selectQuery_in_query254 = new BitSet(new long[]{0x0000000000080000L});
 25240  7 
     public static final BitSet FOLLOW_constructQuery_in_query258 = new BitSet(new long[]{0x0000000000080000L});
 25241  7 
     public static final BitSet FOLLOW_describeQuery_in_query262 = new BitSet(new long[]{0x0000000000080000L});
 25242  7 
     public static final BitSet FOLLOW_askQuery_in_query266 = new BitSet(new long[]{0x0000000000080000L});
 25243  7 
     public static final BitSet FOLLOW_bindingsClause_in_query269 = new BitSet(new long[]{0x0000000000000000L});
 25244  7 
     public static final BitSet FOLLOW_EOF_in_query271 = new BitSet(new long[]{0x0000000000000002L});
 25245  7 
     public static final BitSet FOLLOW_update_in_query302 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25246  7 
     public static final BitSet FOLLOW_212_in_query305 = new BitSet(new long[]{0x0100405010020040L,0x0001008000040000L,0x0000000000020000L,0x0000000000104000L});
 25247  7 
     public static final BitSet FOLLOW_update_in_query307 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25248  7 
     public static final BitSet FOLLOW_EOF_in_query312 = new BitSet(new long[]{0x0000000000000002L});
 25249  7 
     public static final BitSet FOLLOW_baseDecl_in_prologue345 = new BitSet(new long[]{0x0000000000020002L,0x0000000000000000L,0x0000000000020000L});
 25250  7 
     public static final BitSet FOLLOW_prefixDecl_in_prologue349 = new BitSet(new long[]{0x0000000000020002L,0x0000000000000000L,0x0000000000020000L});
 25251  7 
     public static final BitSet FOLLOW_BASE_in_baseDecl380 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L});
 25252  7 
     public static final BitSet FOLLOW_IRI_REF_in_baseDecl382 = new BitSet(new long[]{0x0000000000000002L});
 25253  7 
     public static final BitSet FOLLOW_PREFIX_in_prefixDecl408 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
 25254  7 
     public static final BitSet FOLLOW_PNAME_NS_in_prefixDecl410 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L});
 25255  7 
     public static final BitSet FOLLOW_IRI_REF_in_prefixDecl412 = new BitSet(new long[]{0x0000000000000002L});
 25256  7 
     public static final BitSet FOLLOW_selectClause_in_selectQuery439 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25257  7 
     public static final BitSet FOLLOW_datasetClause_in_selectQuery441 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25258  7 
     public static final BitSet FOLLOW_whereClause_in_selectQuery444 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25259  7 
     public static final BitSet FOLLOW_solutionModifier_in_selectQuery446 = new BitSet(new long[]{0x0000000000000002L});
 25260  7 
     public static final BitSet FOLLOW_selectClause_in_subSelect480 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001001000L});
 25261  7 
     public static final BitSet FOLLOW_whereClause_in_subSelect482 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25262  7 
     public static final BitSet FOLLOW_solutionModifier_in_subSelect484 = new BitSet(new long[]{0x0000000000000002L});
 25263  7 
     public static final BitSet FOLLOW_SELECT_in_selectClause520 = new BitSet(new long[]{0x0004000000008000L,0x0000000000000000L,0x0000000000800000L});
 25264  7 
     public static final BitSet FOLLOW_DISTINCT_in_selectClause523 = new BitSet(new long[]{0x0000000000008000L});
 25265  7 
     public static final BitSet FOLLOW_REDUCED_in_selectClause527 = new BitSet(new long[]{0x0000000000008000L});
 25266  7 
     public static final BitSet FOLLOW_ASTERISK_in_selectClause531 = new BitSet(new long[]{0x0000000000000002L});
 25267  7 
     public static final BitSet FOLLOW_SELECT_in_selectClause553 = new BitSet(new long[]{0x0004000000000000L,0x0000000000000000L,0x0000000000800000L,0x0000000000020600L});
 25268  7 
     public static final BitSet FOLLOW_DISTINCT_in_selectClause556 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020600L});
 25269  7 
     public static final BitSet FOLLOW_REDUCED_in_selectClause560 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020600L});
 25270  7 
     public static final BitSet FOLLOW_selectVariables_in_selectClause567 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000020600L});
 25271  7 
     public static final BitSet FOLLOW_var_in_selectVariables602 = new BitSet(new long[]{0x0000000000000002L});
 25272  7 
     public static final BitSet FOLLOW_209_in_selectVariables619 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25273  7 
     public static final BitSet FOLLOW_expression_in_selectVariables621 = new BitSet(new long[]{0x0000000000001000L});
 25274  7 
     public static final BitSet FOLLOW_AS_in_selectVariables623 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000600L});
 25275  7 
     public static final BitSet FOLLOW_var_in_selectVariables625 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25276  7 
     public static final BitSet FOLLOW_210_in_selectVariables627 = new BitSet(new long[]{0x0000000000000002L});
 25277  7 
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery654 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25278  7 
     public static final BitSet FOLLOW_constructTemplate_in_constructQuery656 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25279  7 
     public static final BitSet FOLLOW_datasetClause_in_constructQuery658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25280  7 
     public static final BitSet FOLLOW_whereClause_in_constructQuery661 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25281  7 
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery663 = new BitSet(new long[]{0x0000000000000002L});
 25282  7 
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery691 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000000001000L});
 25283  7 
     public static final BitSet FOLLOW_datasetClause_in_constructQuery693 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000000001000L});
 25284  7 
     public static final BitSet FOLLOW_WHERE_in_constructQuery696 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25285  7 
     public static final BitSet FOLLOW_216_in_constructQuery698 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000004220600L});
 25286  7 
     public static final BitSet FOLLOW_triplesTemplate_in_constructQuery700 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25287  7 
     public static final BitSet FOLLOW_218_in_constructQuery703 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25288  7 
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery705 = new BitSet(new long[]{0x0000000000000002L});
 25289  7 
     public static final BitSet FOLLOW_DESCRIBE_in_describeQuery741 = new BitSet(new long[]{0x0000000000008000L,0x0000000002000000L,0x0000000000000300L,0x0000000000000600L});
 25290  7 
     public static final BitSet FOLLOW_varOrIRIref_in_describeQuery747 = new BitSet(new long[]{0x0000000000000000L,0x1200004002002108L,0x0000000000000300L,0x0000000001001600L});
 25291  7 
     public static final BitSet FOLLOW_ASTERISK_in_describeQuery753 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002108L,0x0000000000000000L,0x0000000001001000L});
 25292  7 
     public static final BitSet FOLLOW_datasetClause_in_describeQuery756 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002108L,0x0000000000000000L,0x0000000001001000L});
 25293  7 
     public static final BitSet FOLLOW_whereClause_in_describeQuery759 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25294  7 
     public static final BitSet FOLLOW_solutionModifier_in_describeQuery762 = new BitSet(new long[]{0x0000000000000002L});
 25295  7 
     public static final BitSet FOLLOW_ASK_in_askQuery801 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25296  7 
     public static final BitSet FOLLOW_datasetClause_in_askQuery803 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25297  7 
     public static final BitSet FOLLOW_whereClause_in_askQuery806 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25298  7 
     public static final BitSet FOLLOW_solutionModifier_in_askQuery808 = new BitSet(new long[]{0x0000000000000002L});
 25299  7 
     public static final BitSet FOLLOW_FROM_in_datasetClause839 = new BitSet(new long[]{0x0000000000000000L,0x0002000002000000L,0x0000000000000300L});
 25300  7 
     public static final BitSet FOLLOW_NAMED_in_datasetClause841 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25301  7 
     public static final BitSet FOLLOW_iriRef_in_datasetClause844 = new BitSet(new long[]{0x0000000000000002L});
 25302  7 
     public static final BitSet FOLLOW_WHERE_in_whereClause872 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25303  7 
     public static final BitSet FOLLOW_groupGraphPattern_in_whereClause875 = new BitSet(new long[]{0x0000000000000002L});
 25304  7 
     public static final BitSet FOLLOW_groupClause_in_solutionModifier900 = new BitSet(new long[]{0x0000000000000002L,0x1200004000002000L});
 25305  7 
     public static final BitSet FOLLOW_havingClause_in_solutionModifier903 = new BitSet(new long[]{0x0000000000000002L,0x1200004000000000L});
 25306  7 
     public static final BitSet FOLLOW_orderClause_in_solutionModifier906 = new BitSet(new long[]{0x0000000000000002L,0x0200004000000000L});
 25307  7 
     public static final BitSet FOLLOW_limitOffsetClauses_in_solutionModifier909 = new BitSet(new long[]{0x0000000000000002L});
 25308  7 
     public static final BitSet FOLLOW_GROUP_in_groupClause941 = new BitSet(new long[]{0x0000000004000000L});
 25309  7 
     public static final BitSet FOLLOW_BY_in_groupClause943 = new BitSet(new long[]{0x2400030929800020L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030643L});
 25310  7 
     public static final BitSet FOLLOW_groupCondition_in_groupClause945 = new BitSet(new long[]{0x2400030929800022L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030643L});
 25311  7 
     public static final BitSet FOLLOW_builtInCall_in_groupCondition979 = new BitSet(new long[]{0x0000000000000002L});
 25312  7 
     public static final BitSet FOLLOW_functionCall_in_groupCondition995 = new BitSet(new long[]{0x0000000000000002L});
 25313  7 
     public static final BitSet FOLLOW_209_in_groupCondition1011 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25314  7 
     public static final BitSet FOLLOW_expression_in_groupCondition1013 = new BitSet(new long[]{0x0000000000001000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25315  7 
     public static final BitSet FOLLOW_AS_in_groupCondition1016 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000600L});
 25316  7 
     public static final BitSet FOLLOW_var_in_groupCondition1018 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25317  7 
     public static final BitSet FOLLOW_210_in_groupCondition1022 = new BitSet(new long[]{0x0000000000000002L});
 25318  7 
     public static final BitSet FOLLOW_var_in_groupCondition1041 = new BitSet(new long[]{0x0000000000000002L});
 25319  7 
     public static final BitSet FOLLOW_HAVING_in_havingClause1070 = new BitSet(new long[]{0x2400030929800020L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030043L});
 25320  7 
     public static final BitSet FOLLOW_constraint_in_havingClause1072 = new BitSet(new long[]{0x2400030929800022L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030043L});
 25321  7 
     public static final BitSet FOLLOW_ORDER_in_orderClause1104 = new BitSet(new long[]{0x0000000004000000L});
 25322  7 
     public static final BitSet FOLLOW_BY_in_orderClause1106 = new BitSet(new long[]{0x2400830929802020L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030643L});
 25323  7 
     public static final BitSet FOLLOW_orderCondition_in_orderClause1108 = new BitSet(new long[]{0x2400830929802022L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030643L});
 25324  7 
     public static final BitSet FOLLOW_ASC_in_orderCondition1135 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25325  7 
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1137 = new BitSet(new long[]{0x0000000000000002L});
 25326  7 
     public static final BitSet FOLLOW_DESC_in_orderCondition1155 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25327  7 
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1157 = new BitSet(new long[]{0x0000000000000002L});
 25328  7 
     public static final BitSet FOLLOW_constraint_in_orderCondition1175 = new BitSet(new long[]{0x0000000000000002L});
 25329  7 
     public static final BitSet FOLLOW_var_in_orderCondition1191 = new BitSet(new long[]{0x0000000000000002L});
 25330  7 
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1221 = new BitSet(new long[]{0x0000000000000002L,0x0200000000000000L});
 25331  7 
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1223 = new BitSet(new long[]{0x0000000000000002L});
 25332  7 
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1239 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L});
 25333  7 
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1241 = new BitSet(new long[]{0x0000000000000002L});
 25334  7 
     public static final BitSet FOLLOW_LIMIT_in_limitClause1266 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25335  7 
     public static final BitSet FOLLOW_INTEGER_in_limitClause1268 = new BitSet(new long[]{0x0000000000000002L});
 25336  7 
     public static final BitSet FOLLOW_OFFSET_in_offsetClause1293 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25337  7 
     public static final BitSet FOLLOW_INTEGER_in_offsetClause1295 = new BitSet(new long[]{0x0000000000000002L});
 25338  7 
     public static final BitSet FOLLOW_BINDINGS_in_bindingsClause1321 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000600L});
 25339  7 
     public static final BitSet FOLLOW_var_in_bindingsClause1323 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000600L});
 25340  7 
     public static final BitSet FOLLOW_216_in_bindingsClause1326 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004020000L});
 25341  7 
     public static final BitSet FOLLOW_bindingValueList_in_bindingsClause1328 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004020000L});
 25342  7 
     public static final BitSet FOLLOW_218_in_bindingsClause1331 = new BitSet(new long[]{0x0000000000000002L});
 25343  7 
     public static final BitSet FOLLOW_209_in_bindingValueList1367 = new BitSet(new long[]{0x00E01C0000000000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000040008L});
 25344  7 
     public static final BitSet FOLLOW_bindingValue_in_bindingValueList1369 = new BitSet(new long[]{0x00E01C0000000000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000040008L});
 25345  7 
     public static final BitSet FOLLOW_210_in_bindingValueList1372 = new BitSet(new long[]{0x0000000000000002L});
 25346  7 
     public static final BitSet FOLLOW_iriRef_in_bindingValue1403 = new BitSet(new long[]{0x0000000000000002L});
 25347  7 
     public static final BitSet FOLLOW_rdfLiteral_in_bindingValue1407 = new BitSet(new long[]{0x0000000000000002L});
 25348  7 
     public static final BitSet FOLLOW_numericLiteral_in_bindingValue1411 = new BitSet(new long[]{0x0000000000000002L});
 25349  7 
     public static final BitSet FOLLOW_booleanLiteral_in_bindingValue1415 = new BitSet(new long[]{0x0000000000000002L});
 25350  7 
     public static final BitSet FOLLOW_UNDEF_in_bindingValue1419 = new BitSet(new long[]{0x0000000000000002L});
 25351  7 
     public static final BitSet FOLLOW_prologue_in_update1440 = new BitSet(new long[]{0x0100405010000040L,0x0001008000040000L,0x0000000000000000L,0x0000000000004000L});
 25352  7 
     public static final BitSet FOLLOW_load_in_update1443 = new BitSet(new long[]{0x0000000000000002L});
 25353  7 
     public static final BitSet FOLLOW_clear_in_update1447 = new BitSet(new long[]{0x0000000000000002L});
 25354  7 
     public static final BitSet FOLLOW_drop_in_update1451 = new BitSet(new long[]{0x0000000000000002L});
 25355  7 
     public static final BitSet FOLLOW_add_in_update1455 = new BitSet(new long[]{0x0000000000000002L});
 25356  7 
     public static final BitSet FOLLOW_move_in_update1459 = new BitSet(new long[]{0x0000000000000002L});
 25357  7 
     public static final BitSet FOLLOW_copy_in_update1463 = new BitSet(new long[]{0x0000000000000002L});
 25358  7 
     public static final BitSet FOLLOW_create_in_update1467 = new BitSet(new long[]{0x0000000000000002L});
 25359  7 
     public static final BitSet FOLLOW_insert_in_update1471 = new BitSet(new long[]{0x0000000000000002L});
 25360  7 
     public static final BitSet FOLLOW_delete_in_update1475 = new BitSet(new long[]{0x0000000000000002L});
 25361  7 
     public static final BitSet FOLLOW_modify_in_update1479 = new BitSet(new long[]{0x0000000000000002L});
 25362  7 
     public static final BitSet FOLLOW_LOAD_in_load1542 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000010000000300L});
 25363  7 
     public static final BitSet FOLLOW_SILENT_in_load1544 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25364  7 
     public static final BitSet FOLLOW_iriRef_in_load1547 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
 25365  7 
     public static final BitSet FOLLOW_INTO_in_load1550 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
 25366  7 
     public static final BitSet FOLLOW_graphRef_in_load1552 = new BitSet(new long[]{0x0000000000000002L});
 25367  7 
     public static final BitSet FOLLOW_CLEAR_in_clear1589 = new BitSet(new long[]{0x0000200000000080L,0x0002000000000020L,0x0000010000000000L});
 25368  7 
     public static final BitSet FOLLOW_SILENT_in_clear1592 = new BitSet(new long[]{0x0000200000000080L,0x0002000000000020L});
 25369  7 
     public static final BitSet FOLLOW_graphRefAll_in_clear1595 = new BitSet(new long[]{0x0000000000000002L});
 25370  7 
     public static final BitSet FOLLOW_DROP_in_drop1627 = new BitSet(new long[]{0x0000200000000080L,0x0002000000000020L,0x0000010000000000L});
 25371  7 
     public static final BitSet FOLLOW_SILENT_in_drop1629 = new BitSet(new long[]{0x0000200000000080L,0x0002000000000020L});
 25372  7 
     public static final BitSet FOLLOW_graphRefAll_in_drop1632 = new BitSet(new long[]{0x0000000000000002L});
 25373  7 
     public static final BitSet FOLLOW_CREATE_in_create1661 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L,0x0000010000000000L});
 25374  7 
     public static final BitSet FOLLOW_SILENT_in_create1663 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
 25375  7 
     public static final BitSet FOLLOW_graphRef_in_create1666 = new BitSet(new long[]{0x0000000000000002L});
 25376  7 
     public static final BitSet FOLLOW_ADD_in_add1698 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000010000000300L});
 25377  7 
     public static final BitSet FOLLOW_SILENT_in_add1700 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25378  7 
     public static final BitSet FOLLOW_graphOrDefault_in_add1705 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L});
 25379  7 
     public static final BitSet FOLLOW_TO_in_add1707 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25380  7 
     public static final BitSet FOLLOW_graphOrDefault_in_add1711 = new BitSet(new long[]{0x0000000000000002L});
 25381  7 
     public static final BitSet FOLLOW_MOVE_in_move1747 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000010000000300L});
 25382  7 
     public static final BitSet FOLLOW_SILENT_in_move1749 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25383  7 
     public static final BitSet FOLLOW_graphOrDefault_in_move1754 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L});
 25384  7 
     public static final BitSet FOLLOW_TO_in_move1756 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25385  7 
     public static final BitSet FOLLOW_graphOrDefault_in_move1760 = new BitSet(new long[]{0x0000000000000002L});
 25386  7 
     public static final BitSet FOLLOW_COPY_in_copy1796 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000010000000300L});
 25387  7 
     public static final BitSet FOLLOW_SILENT_in_copy1798 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25388  7 
     public static final BitSet FOLLOW_graphOrDefault_in_copy1803 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L});
 25389  7 
     public static final BitSet FOLLOW_TO_in_copy1805 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25390  7 
     public static final BitSet FOLLOW_graphOrDefault_in_copy1809 = new BitSet(new long[]{0x0000000000000002L});
 25391  7 
     public static final BitSet FOLLOW_INSERT_in_insert1841 = new BitSet(new long[]{0x0000008000000000L});
 25392  7 
     public static final BitSet FOLLOW_DATA_in_insert1843 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25393  7 
     public static final BitSet FOLLOW_quadPattern_in_insert1845 = new BitSet(new long[]{0x0000000000000002L});
 25394  7 
     public static final BitSet FOLLOW_DELETE_in_delete1879 = new BitSet(new long[]{0x0000008000000000L});
 25395  7 
     public static final BitSet FOLLOW_deleteData_in_delete1881 = new BitSet(new long[]{0x0000000000000002L});
 25396  7 
     public static final BitSet FOLLOW_DELETE_in_delete1897 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
 25397  7 
     public static final BitSet FOLLOW_deleteWhere_in_delete1899 = new BitSet(new long[]{0x0000000000000002L});
 25398  7 
     public static final BitSet FOLLOW_DATA_in_deleteData1924 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25399  7 
     public static final BitSet FOLLOW_quadPattern_in_deleteData1926 = new BitSet(new long[]{0x0000000000000002L});
 25400  7 
     public static final BitSet FOLLOW_WHERE_in_deleteWhere1953 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25401  7 
     public static final BitSet FOLLOW_quadPattern_in_deleteWhere1955 = new BitSet(new long[]{0x0000000000000002L});
 25402  7 
     public static final BitSet FOLLOW_WITH_in_modify1987 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25403  7 
     public static final BitSet FOLLOW_iriRef_in_modify1989 = new BitSet(new long[]{0x0000400000000000L,0x0000000000040000L});
 25404  7 
     public static final BitSet FOLLOW_deleteClause_in_modify1994 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L,0x0000000000000000L,0x0000000000001080L});
 25405  7 
     public static final BitSet FOLLOW_insertClause_in_modify1996 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000001080L});
 25406  7 
     public static final BitSet FOLLOW_insertClause_in_modify2001 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000001080L});
 25407  7 
     public static final BitSet FOLLOW_usingClause_in_modify2004 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000001080L});
 25408  7 
     public static final BitSet FOLLOW_WHERE_in_modify2007 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25409  7 
     public static final BitSet FOLLOW_groupGraphPattern_in_modify2009 = new BitSet(new long[]{0x0000000000000002L});
 25410  7 
     public static final BitSet FOLLOW_DELETE_in_deleteClause2056 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25411  7 
     public static final BitSet FOLLOW_quadPattern_in_deleteClause2058 = new BitSet(new long[]{0x0000000000000002L});
 25412  7 
     public static final BitSet FOLLOW_INSERT_in_insertClause2089 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25413  7 
     public static final BitSet FOLLOW_quadPattern_in_insertClause2091 = new BitSet(new long[]{0x0000000000000002L});
 25414  7 
     public static final BitSet FOLLOW_USING_in_usingClause2116 = new BitSet(new long[]{0x0000000000000000L,0x0002000002000000L,0x0000000000000300L});
 25415  7 
     public static final BitSet FOLLOW_NAMED_in_usingClause2118 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25416  7 
     public static final BitSet FOLLOW_iriRef_in_usingClause2121 = new BitSet(new long[]{0x0000000000000002L});
 25417  7 
     public static final BitSet FOLLOW_DEFAULT_in_graphOrDefault2152 = new BitSet(new long[]{0x0000000000000002L});
 25418  7 
     public static final BitSet FOLLOW_GRAPH_in_graphOrDefault2161 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25419  7 
     public static final BitSet FOLLOW_iriRef_in_graphOrDefault2164 = new BitSet(new long[]{0x0000000000000002L});
 25420  7 
     public static final BitSet FOLLOW_GRAPH_in_graphRef2191 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25421  7 
     public static final BitSet FOLLOW_iriRef_in_graphRef2193 = new BitSet(new long[]{0x0000000000000002L});
 25422  7 
     public static final BitSet FOLLOW_graphRef_in_graphRefAll2210 = new BitSet(new long[]{0x0000000000000002L});
 25423  7 
     public static final BitSet FOLLOW_DEFAULT_in_graphRefAll2214 = new BitSet(new long[]{0x0000000000000002L});
 25424  7 
     public static final BitSet FOLLOW_NAMED_in_graphRefAll2218 = new BitSet(new long[]{0x0000000000000002L});
 25425  7 
     public static final BitSet FOLLOW_ALL_in_graphRefAll2222 = new BitSet(new long[]{0x0000000000000002L});
 25426  7 
     public static final BitSet FOLLOW_216_in_quadPattern2239 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380021L,0x8003C00000000300L,0x0000000004220600L});
 25427  7 
     public static final BitSet FOLLOW_quads_in_quadPattern2241 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25428  7 
     public static final BitSet FOLLOW_218_in_quadPattern2243 = new BitSet(new long[]{0x0000000000000002L});
 25429  7 
     public static final BitSet FOLLOW_triplesTemplate_in_quads2268 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
 25430  7 
     public static final BitSet FOLLOW_quadsDetails_in_quads2271 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
 25431  7 
     public static final BitSet FOLLOW_quadsNotTriples_in_quadsDetails2303 = new BitSet(new long[]{0x00F01C0000400002L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25432  7 
     public static final BitSet FOLLOW_DOT_in_quadsDetails2305 = new BitSet(new long[]{0x00E01C0000400002L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25433  7 
     public static final BitSet FOLLOW_triplesTemplate_in_quadsDetails2308 = new BitSet(new long[]{0x0000000000000002L});
 25434  7 
     public static final BitSet FOLLOW_GRAPH_in_quadsNotTriples2338 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L,0x0000000000000600L});
 25435  7 
     public static final BitSet FOLLOW_varOrIRIref_in_quadsNotTriples2340 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25436  7 
     public static final BitSet FOLLOW_216_in_quadsNotTriples2342 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000004220600L});
 25437  7 
     public static final BitSet FOLLOW_triplesTemplate_in_quadsNotTriples2344 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25438  7 
     public static final BitSet FOLLOW_218_in_quadsNotTriples2347 = new BitSet(new long[]{0x0000000000000002L});
 25439  7 
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2379 = new BitSet(new long[]{0x0010000000000002L});
 25440  7 
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2382 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25441  7 
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2384 = new BitSet(new long[]{0x0010000000000002L});
 25442  7 
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2388 = new BitSet(new long[]{0x0000000000000002L});
 25443  7 
     public static final BitSet FOLLOW_216_in_groupGraphPattern2420 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
 25444  7 
     public static final BitSet FOLLOW_subSelect_in_groupGraphPattern2422 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25445  7 
     public static final BitSet FOLLOW_218_in_groupGraphPattern2424 = new BitSet(new long[]{0x0000000000000002L});
 25446  7 
     public static final BitSet FOLLOW_216_in_groupGraphPattern2440 = new BitSet(new long[]{0x00E01C0000440000L,0x0400100002380023L,0x8003C00200000300L,0x0000000001220600L});
 25447  7 
     public static final BitSet FOLLOW_groupGraphPatternSub_in_groupGraphPattern2442 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25448  7 
     public static final BitSet FOLLOW_218_in_groupGraphPattern2444 = new BitSet(new long[]{0x0000000000000002L});
 25449  7 
     public static final BitSet FOLLOW_216_in_groupGraphPattern2460 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25450  7 
     public static final BitSet FOLLOW_218_in_groupGraphPattern2462 = new BitSet(new long[]{0x0000000000000002L});
 25451  7 
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSub2491 = new BitSet(new long[]{0x0000000000040002L,0x0400100000000022L,0x0000000200000000L,0x0000000001000000L});
 25452  7 
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2493 = new BitSet(new long[]{0x0000000000040002L,0x0400100000000022L,0x0000000200000000L,0x0000000001000000L});
 25453  7 
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2509 = new BitSet(new long[]{0x0000000000040002L,0x0400100000000022L,0x0000000200000000L,0x0000000001000000L});
 25454  7 
     public static final BitSet FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2532 = new BitSet(new long[]{0x00F01C0000400002L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25455  7 
     public static final BitSet FOLLOW_DOT_in_groupGraphPatternSubDetail2534 = new BitSet(new long[]{0x00E01C0000400002L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25456  7 
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2537 = new BitSet(new long[]{0x0000000000000002L});
 25457  7 
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2562 = new BitSet(new long[]{0x0010000000000002L});
 25458  7 
     public static final BitSet FOLLOW_DOT_in_triplesBlock2565 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25459  7 
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2567 = new BitSet(new long[]{0x0010000000000002L});
 25460  7 
     public static final BitSet FOLLOW_DOT_in_triplesBlock2571 = new BitSet(new long[]{0x0000000000000002L});
 25461  7 
     public static final BitSet FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2594 = new BitSet(new long[]{0x0000000000000002L});
 25462  7 
     public static final BitSet FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2598 = new BitSet(new long[]{0x0000000000000002L});
 25463  7 
     public static final BitSet FOLLOW_minusGraphPattern_in_graphPatternNotTriples2602 = new BitSet(new long[]{0x0000000000000002L});
 25464  7 
     public static final BitSet FOLLOW_graphGraphPattern_in_graphPatternNotTriples2606 = new BitSet(new long[]{0x0000000000000002L});
 25465  7 
     public static final BitSet FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2610 = new BitSet(new long[]{0x0000000000000002L});
 25466  7 
     public static final BitSet FOLLOW_filter_in_graphPatternNotTriples2614 = new BitSet(new long[]{0x0000000000000002L});
 25467  7 
     public static final BitSet FOLLOW_bind_in_graphPatternNotTriples2618 = new BitSet(new long[]{0x0000000000000002L});
 25468  7 
     public static final BitSet FOLLOW_OPTIONAL_in_optionalGraphPattern2635 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25469  7 
     public static final BitSet FOLLOW_groupGraphPattern_in_optionalGraphPattern2637 = new BitSet(new long[]{0x0000000000000002L});
 25470  7 
     public static final BitSet FOLLOW_GRAPH_in_graphGraphPattern2662 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L,0x0000000000000600L});
 25471  7 
     public static final BitSet FOLLOW_varOrIRIref_in_graphGraphPattern2664 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25472  7 
     public static final BitSet FOLLOW_groupGraphPattern_in_graphGraphPattern2666 = new BitSet(new long[]{0x0000000000000002L});
 25473  7 
     public static final BitSet FOLLOW_SERVICE_in_serviceGraphPattern2693 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000010000000300L,0x0000000000000600L});
 25474  7 
     public static final BitSet FOLLOW_SILENT_in_serviceGraphPattern2695 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L,0x0000000000000600L});
 25475  7 
     public static final BitSet FOLLOW_varOrIRIref_in_serviceGraphPattern2698 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25476  7 
     public static final BitSet FOLLOW_groupGraphPattern_in_serviceGraphPattern2700 = new BitSet(new long[]{0x0000000000000002L});
 25477  7 
     public static final BitSet FOLLOW_BIND_in_bind2734 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25478  7 
     public static final BitSet FOLLOW_209_in_bind2736 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25479  7 
     public static final BitSet FOLLOW_expression_in_bind2738 = new BitSet(new long[]{0x0000000000001000L});
 25480  7 
     public static final BitSet FOLLOW_AS_in_bind2740 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000600L});
 25481  7 
     public static final BitSet FOLLOW_var_in_bind2742 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25482  7 
     public static final BitSet FOLLOW_210_in_bind2744 = new BitSet(new long[]{0x0000000000000002L});
 25483  7 
     public static final BitSet FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2781 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25484  7 
     public static final BitSet FOLLOW_groupGraphPattern_in_minusGraphPattern2783 = new BitSet(new long[]{0x0000000000000002L});
 25485  7 
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2811 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000010L});
 25486  7 
     public static final BitSet FOLLOW_UNION_in_groupOrUnionGraphPattern2819 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25487  7 
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2823 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000010L});
 25488  7 
     public static final BitSet FOLLOW_FILTER_in_filter2855 = new BitSet(new long[]{0x2400030929800020L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030043L});
 25489  7 
     public static final BitSet FOLLOW_constraint_in_filter2857 = new BitSet(new long[]{0x0000000000000002L});
 25490  7 
     public static final BitSet FOLLOW_brackettedExpression_in_constraint2882 = new BitSet(new long[]{0x0000000000000002L});
 25491  7 
     public static final BitSet FOLLOW_builtInCall_in_constraint2890 = new BitSet(new long[]{0x0000000000000002L});
 25492  7 
     public static final BitSet FOLLOW_functionCall_in_constraint2898 = new BitSet(new long[]{0x0000000000000002L});
 25493  7 
     public static final BitSet FOLLOW_iriRef_in_functionCall2915 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25494  7 
     public static final BitSet FOLLOW_argList_in_functionCall2917 = new BitSet(new long[]{0x0000000000000002L});
 25495  7 
     public static final BitSet FOLLOW_nil_in_argList2948 = new BitSet(new long[]{0x0000000000000002L});
 25496  7 
     public static final BitSet FOLLOW_209_in_argList2960 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25497  7 
     public static final BitSet FOLLOW_DISTINCT_in_argList2962 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25498  7 
     public static final BitSet FOLLOW_expression_in_argList2965 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25499  7 
     public static final BitSet FOLLOW_211_in_argList2968 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25500  7 
     public static final BitSet FOLLOW_expression_in_argList2970 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25501  7 
     public static final BitSet FOLLOW_210_in_argList2974 = new BitSet(new long[]{0x0000000000000002L});
 25502  7 
     public static final BitSet FOLLOW_nil_in_expressionList3000 = new BitSet(new long[]{0x0000000000000002L});
 25503  7 
     public static final BitSet FOLLOW_209_in_expressionList3004 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25504  7 
     public static final BitSet FOLLOW_expression_in_expressionList3006 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25505  7 
     public static final BitSet FOLLOW_211_in_expressionList3009 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25506  7 
     public static final BitSet FOLLOW_expression_in_expressionList3011 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25507  7 
     public static final BitSet FOLLOW_210_in_expressionList3015 = new BitSet(new long[]{0x0000000000000002L});
 25508  7 
     public static final BitSet FOLLOW_216_in_constructTemplate3046 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000004220600L});
 25509  7 
     public static final BitSet FOLLOW_constructTriples_in_constructTemplate3048 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25510  7 
     public static final BitSet FOLLOW_218_in_constructTemplate3051 = new BitSet(new long[]{0x0000000000000002L});
 25511  7 
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples3077 = new BitSet(new long[]{0x0010000000000002L});
 25512  7 
     public static final BitSet FOLLOW_DOT_in_constructTriples3080 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25513  7 
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples3082 = new BitSet(new long[]{0x0010000000000002L});
 25514  7 
     public static final BitSet FOLLOW_DOT_in_constructTriples3086 = new BitSet(new long[]{0x0000000000000002L});
 25515  7 
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubject3109 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25516  7 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject3111 = new BitSet(new long[]{0x0000000000000002L});
 25517  7 
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubject3135 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25518  7 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject3137 = new BitSet(new long[]{0x0000000000000002L});
 25519  7 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3167 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25520  7 
     public static final BitSet FOLLOW_212_in_propertyListNotEmpty3170 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000120600L});
 25521  7 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3172 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25522  7 
     public static final BitSet FOLLOW_graphNode_in_objectList3198 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25523  7 
     public static final BitSet FOLLOW_211_in_objectList3201 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25524  7 
     public static final BitSet FOLLOW_graphNode_in_objectList3203 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25525  7 
     public static final BitSet FOLLOW_varOrIRIref_in_verb3231 = new BitSet(new long[]{0x0000000000000002L});
 25526  7 
     public static final BitSet FOLLOW_A_in_verb3239 = new BitSet(new long[]{0x0000000000000002L});
 25527  7 
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubjectPath3256 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25528  7 
     public static final BitSet FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3258 = new BitSet(new long[]{0x0000000000000002L});
 25529  7 
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubjectPath3280 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25530  7 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3282 = new BitSet(new long[]{0x0000000000000002L});
 25531  7 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3314 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25532  7 
     public static final BitSet FOLLOW_212_in_propertyListNotEmptyPath3317 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000120600L});
 25533  7 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3319 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25534  7 
     public static final BitSet FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3346 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25535  7 
     public static final BitSet FOLLOW_objectList_in_propertyListNotEmptyDetails3348 = new BitSet(new long[]{0x0000000000000002L});
 25536  7 
     public static final BitSet FOLLOW_verbPath_in_verbSimpleOrPath3378 = new BitSet(new long[]{0x0000000000000002L});
 25537  7 
     public static final BitSet FOLLOW_verbSimple_in_verbSimpleOrPath3386 = new BitSet(new long[]{0x0000000000000002L});
 25538  7 
     public static final BitSet FOLLOW_path_in_verbPath3405 = new BitSet(new long[]{0x0000000000000002L});
 25539  7 
     public static final BitSet FOLLOW_var_in_verbSimple3426 = new BitSet(new long[]{0x0000000000000002L});
 25540  7 
     public static final BitSet FOLLOW_pathSequence_in_path3448 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000002000000L});
 25541  7 
     public static final BitSet FOLLOW_217_in_path3451 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020000L});
 25542  7 
     public static final BitSet FOLLOW_pathSequence_in_path3453 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000002000000L});
 25543  7 
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3482 = new BitSet(new long[]{0x0008000000000002L});
 25544  7 
     public static final BitSet FOLLOW_DIVIDE_in_pathSequence3485 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020000L});
 25545  7 
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3487 = new BitSet(new long[]{0x0008000000000002L});
 25546  7 
     public static final BitSet FOLLOW_INVERSE_in_pathEltOrInverse3518 = new BitSet(new long[]{0x0000000000000010L,0x0004000002000000L,0x0000000000000300L,0x0000000000020000L});
 25547  7 
     public static final BitSet FOLLOW_pathElt_in_pathEltOrInverse3522 = new BitSet(new long[]{0x0000000000000002L});
 25548  7 
     public static final BitSet FOLLOW_pathPrimary_in_pathElt3562 = new BitSet(new long[]{0x0000000000008002L,0x0000000000000000L,0x0000000000100040L,0x0000000001000000L});
 25549  7 
     public static final BitSet FOLLOW_pathMod_in_pathElt3564 = new BitSet(new long[]{0x0000000000000002L});
 25550  7 
     public static final BitSet FOLLOW_ASTERISK_in_pathMod3582 = new BitSet(new long[]{0x0000000000000002L});
 25551  7 
     public static final BitSet FOLLOW_QUESTION_MARK_in_pathMod3596 = new BitSet(new long[]{0x0000000000000002L});
 25552  7 
     public static final BitSet FOLLOW_PLUS_in_pathMod3611 = new BitSet(new long[]{0x0000000000000002L});
 25553  7 
     public static final BitSet FOLLOW_216_in_pathMod3626 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25554  7 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3630 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25555  7 
     public static final BitSet FOLLOW_218_in_pathMod3632 = new BitSet(new long[]{0x0000000000000002L});
 25556  7 
     public static final BitSet FOLLOW_216_in_pathMod3647 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25557  7 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3651 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25558  7 
     public static final BitSet FOLLOW_211_in_pathMod3655 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25559  7 
     public static final BitSet FOLLOW_218_in_pathMod3657 = new BitSet(new long[]{0x0000000000000002L});
 25560  7 
     public static final BitSet FOLLOW_216_in_pathMod3675 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25561  7 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3679 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25562  7 
     public static final BitSet FOLLOW_211_in_pathMod3681 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25563  7 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3685 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25564  7 
     public static final BitSet FOLLOW_218_in_pathMod3687 = new BitSet(new long[]{0x0000000000000002L});
 25565  7 
     public static final BitSet FOLLOW_216_in_pathMod3706 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25566  7 
     public static final BitSet FOLLOW_211_in_pathMod3710 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25567  7 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3714 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25568  7 
     public static final BitSet FOLLOW_218_in_pathMod3716 = new BitSet(new long[]{0x0000000000000002L});
 25569  7 
     public static final BitSet FOLLOW_iriRef_in_pathPrimary3743 = new BitSet(new long[]{0x0000000000000002L});
 25570  7 
     public static final BitSet FOLLOW_A_in_pathPrimary3759 = new BitSet(new long[]{0x0000000000000002L});
 25571  7 
     public static final BitSet FOLLOW_NEGATION_in_pathPrimary3775 = new BitSet(new long[]{0x0000000000000010L,0x0000000002800000L,0x0000000000000300L,0x0000000000020000L});
 25572  7 
     public static final BitSet FOLLOW_pathNegatedPropertySet_in_pathPrimary3777 = new BitSet(new long[]{0x0000000000000002L});
 25573  7 
     public static final BitSet FOLLOW_209_in_pathPrimary3793 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020000L});
 25574  7 
     public static final BitSet FOLLOW_path_in_pathPrimary3795 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25575  7 
     public static final BitSet FOLLOW_210_in_pathPrimary3797 = new BitSet(new long[]{0x0000000000000002L});
 25576  7 
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3822 = new BitSet(new long[]{0x0000000000000002L});
 25577  7 
     public static final BitSet FOLLOW_209_in_pathNegatedPropertySet3838 = new BitSet(new long[]{0x0000000000000010L,0x0000000002800000L,0x0000000000000300L,0x0000000000040000L});
 25578  7 
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3841 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000002040000L});
 25579  7 
     public static final BitSet FOLLOW_217_in_pathNegatedPropertySet3844 = new BitSet(new long[]{0x0000000000000010L,0x0000000002800000L,0x0000000000000300L});
 25580  7 
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3846 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000002040000L});
 25581  7 
     public static final BitSet FOLLOW_210_in_pathNegatedPropertySet3852 = new BitSet(new long[]{0x0000000000000002L});
 25582  7 
     public static final BitSet FOLLOW_INVERSE_in_pathOneInPropertySet3881 = new BitSet(new long[]{0x0000000000000010L,0x0000000002000000L,0x0000000000000300L});
 25583  7 
     public static final BitSet FOLLOW_iriRef_in_pathOneInPropertySet3885 = new BitSet(new long[]{0x0000000000000002L});
 25584  7 
     public static final BitSet FOLLOW_A_in_pathOneInPropertySet3889 = new BitSet(new long[]{0x0000000000000002L});
 25585  7 
     public static final BitSet FOLLOW_209_in_triplesNode3908 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25586  7 
     public static final BitSet FOLLOW_graphNode_in_triplesNode3910 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000260600L});
 25587  7 
     public static final BitSet FOLLOW_210_in_triplesNode3913 = new BitSet(new long[]{0x0000000000000002L});
 25588  7 
     public static final BitSet FOLLOW_213_in_triplesNode3930 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25589  7 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesNode3932 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000400000L});
 25590  7 
     public static final BitSet FOLLOW_214_in_triplesNode3934 = new BitSet(new long[]{0x0000000000000002L});
 25591  7 
     public static final BitSet FOLLOW_varOrTerm_in_graphNode3959 = new BitSet(new long[]{0x0000000000000002L});
 25592  7 
     public static final BitSet FOLLOW_triplesNode_in_graphNode3963 = new BitSet(new long[]{0x0000000000000002L});
 25593  7 
     public static final BitSet FOLLOW_var_in_varOrTerm3980 = new BitSet(new long[]{0x0000000000000002L});
 25594  7 
     public static final BitSet FOLLOW_graphTerm_in_varOrTerm3988 = new BitSet(new long[]{0x0000000000000002L});
 25595  7 
     public static final BitSet FOLLOW_var_in_varOrIRIref4005 = new BitSet(new long[]{0x0000000000000002L});
 25596  7 
     public static final BitSet FOLLOW_iriRef_in_varOrIRIref4009 = new BitSet(new long[]{0x0000000000000002L});
 25597  7 
     public static final BitSet FOLLOW_iriRef_in_graphTerm4047 = new BitSet(new long[]{0x0000000000000002L});
 25598  7 
     public static final BitSet FOLLOW_rdfLiteral_in_graphTerm4055 = new BitSet(new long[]{0x0000000000000002L});
 25599  7 
     public static final BitSet FOLLOW_numericLiteral_in_graphTerm4063 = new BitSet(new long[]{0x0000000000000002L});
 25600  7 
     public static final BitSet FOLLOW_booleanLiteral_in_graphTerm4071 = new BitSet(new long[]{0x0000000000000002L});
 25601  7 
     public static final BitSet FOLLOW_blankNode_in_graphTerm4079 = new BitSet(new long[]{0x0000000000000002L});
 25602  7 
     public static final BitSet FOLLOW_nil_in_graphTerm4087 = new BitSet(new long[]{0x0000000000000002L});
 25603  7 
     public static final BitSet FOLLOW_209_in_nil4108 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25604  7 
     public static final BitSet FOLLOW_210_in_nil4110 = new BitSet(new long[]{0x0000000000000002L});
 25605  7 
     public static final BitSet FOLLOW_conditionalOrExpression_in_expression4131 = new BitSet(new long[]{0x0000000000000002L});
 25606  7 
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression4151 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L});
 25607  7 
     public static final BitSet FOLLOW_OR_in_conditionalOrExpression4160 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25608  7 
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression4164 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L});
 25609  7 
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression4198 = new BitSet(new long[]{0x0000000000000102L});
 25610  7 
     public static final BitSet FOLLOW_AND_in_conditionalAndExpression4207 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25611  7 
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression4211 = new BitSet(new long[]{0x0000000000000102L});
 25612  7 
     public static final BitSet FOLLOW_relationalExpression_in_valueLogical4242 = new BitSet(new long[]{0x0000000000000002L});
 25613  7 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4262 = new BitSet(new long[]{0x1000000000000002L,0x00300030000200C0L});
 25614  7 
     public static final BitSet FOLLOW_EQUAL_in_relationalExpression4272 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25615  7 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4276 = new BitSet(new long[]{0x0000000000000002L});
 25616  7 
     public static final BitSet FOLLOW_NOT_EQUAL_in_relationalExpression4333 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25617  7 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4337 = new BitSet(new long[]{0x0000000000000002L});
 25618  7 
     public static final BitSet FOLLOW_LESS_in_relationalExpression4392 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25619  7 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4396 = new BitSet(new long[]{0x0000000000000002L});
 25620  7 
     public static final BitSet FOLLOW_GREATER_in_relationalExpression4451 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25621  7 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4455 = new BitSet(new long[]{0x0000000000000002L});
 25622  7 
     public static final BitSet FOLLOW_LESS_EQUAL_in_relationalExpression4509 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25623  7 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4513 = new BitSet(new long[]{0x0000000000000002L});
 25624  7 
     public static final BitSet FOLLOW_GREATER_EQUAL_in_relationalExpression4567 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25625  7 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4571 = new BitSet(new long[]{0x0000000000000002L});
 25626  7 
     public static final BitSet FOLLOW_IN_in_relationalExpression4627 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25627  7 
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4631 = new BitSet(new long[]{0x0000000000000002L});
 25628  7 
     public static final BitSet FOLLOW_NOT_in_relationalExpression4685 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
 25629  7 
     public static final BitSet FOLLOW_IN_in_relationalExpression4687 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25630  7 
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4691 = new BitSet(new long[]{0x0000000000000002L});
 25631  7 
     public static final BitSet FOLLOW_additiveExpression_in_numericExpression4725 = new BitSet(new long[]{0x0000000000000002L});
 25632  7 
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4745 = new BitSet(new long[]{0x00C0180000000002L,0x0000080000300000L,0x0000000000000040L});
 25633  7 
     public static final BitSet FOLLOW_additiveOperator_in_additiveExpression4755 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25634  7 
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4759 = new BitSet(new long[]{0x00C0180000000002L,0x0000080000300000L,0x0000000000000040L});
 25635  7 
     public static final BitSet FOLLOW_numericLiteralPositive_in_additiveExpression4826 = new BitSet(new long[]{0x00C8180000008002L,0x0000080000300000L,0x0000000000000040L});
 25636  7 
     public static final BitSet FOLLOW_numericLiteralNegative_in_additiveExpression4844 = new BitSet(new long[]{0x00C8180000008002L,0x0000080000300000L,0x0000000000000040L});
 25637  7 
     public static final BitSet FOLLOW_ASTERISK_in_additiveExpression4908 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25638  7 
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4912 = new BitSet(new long[]{0x00C0180000000002L,0x0000080000300000L,0x0000000000000040L});
 25639  7 
     public static final BitSet FOLLOW_DIVIDE_in_additiveExpression4978 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25640  7 
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4982 = new BitSet(new long[]{0x00C0180000000002L,0x0000080000300000L,0x0000000000000040L});
 25641  7 
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression5048 = new BitSet(new long[]{0x0008000000008002L});
 25642  7 
     public static final BitSet FOLLOW_multiplicativeOperator_in_multiplicativeExpression5057 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25643  7 
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression5061 = new BitSet(new long[]{0x0008000000008002L});
 25644  7 
     public static final BitSet FOLLOW_NEGATION_in_unaryExpression5116 = new BitSet(new long[]{0x24E01F2929810020L,0x0090A70BFB398405L,0x839FFE743F200300L,0x0000000000030643L});
 25645  7 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression5118 = new BitSet(new long[]{0x0000000000000002L});
 25646  7 
     public static final BitSet FOLLOW_PLUS_in_unaryExpression5136 = new BitSet(new long[]{0x24E01F2929810020L,0x0090A70BFB398405L,0x839FFE743F200300L,0x0000000000030643L});
 25647  7 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression5138 = new BitSet(new long[]{0x0000000000000002L});
 25648  7 
     public static final BitSet FOLLOW_MINUS_in_unaryExpression5156 = new BitSet(new long[]{0x24E01F2929810020L,0x0090A70BFB398405L,0x839FFE743F200300L,0x0000000000030643L});
 25649  7 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression5158 = new BitSet(new long[]{0x0000000000000002L});
 25650  7 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression5176 = new BitSet(new long[]{0x0000000000000002L});
 25651  7 
     public static final BitSet FOLLOW_brackettedExpression_in_primaryExpression5201 = new BitSet(new long[]{0x0000000000000002L});
 25652  7 
     public static final BitSet FOLLOW_builtInCall_in_primaryExpression5205 = new BitSet(new long[]{0x0000000000000002L});
 25653  7 
     public static final BitSet FOLLOW_iriRefOrFunction_in_primaryExpression5209 = new BitSet(new long[]{0x0000000000000002L});
 25654  7 
     public static final BitSet FOLLOW_rdfLiteral_in_primaryExpression5213 = new BitSet(new long[]{0x0000000000000002L});
 25655  7 
     public static final BitSet FOLLOW_numericLiteral_in_primaryExpression5217 = new BitSet(new long[]{0x0000000000000002L});
 25656  7 
     public static final BitSet FOLLOW_booleanLiteral_in_primaryExpression5221 = new BitSet(new long[]{0x0000000000000002L});
 25657  7 
     public static final BitSet FOLLOW_var_in_primaryExpression5225 = new BitSet(new long[]{0x0000000000000002L});
 25658  7 
     public static final BitSet FOLLOW_aggregate_in_primaryExpression5229 = new BitSet(new long[]{0x0000000000000002L});
 25659  7 
     public static final BitSet FOLLOW_209_in_brackettedExpression5246 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25660  7 
     public static final BitSet FOLLOW_expression_in_brackettedExpression5248 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25661  7 
     public static final BitSet FOLLOW_210_in_brackettedExpression5250 = new BitSet(new long[]{0x0000000000000002L});
 25662  7 
     public static final BitSet FOLLOW_STR_in_builtInCall5275 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25663  7 
     public static final BitSet FOLLOW_209_in_builtInCall5277 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25664  7 
     public static final BitSet FOLLOW_expression_in_builtInCall5279 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25665  7 
     public static final BitSet FOLLOW_210_in_builtInCall5281 = new BitSet(new long[]{0x0000000000000002L});
 25666  7 
     public static final BitSet FOLLOW_LANG_in_builtInCall5297 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25667  7 
     public static final BitSet FOLLOW_209_in_builtInCall5299 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25668  7 
     public static final BitSet FOLLOW_expression_in_builtInCall5301 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25669  7 
     public static final BitSet FOLLOW_210_in_builtInCall5303 = new BitSet(new long[]{0x0000000000000002L});
 25670  7 
     public static final BitSet FOLLOW_LANGMATCHES_in_builtInCall5319 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25671  7 
     public static final BitSet FOLLOW_209_in_builtInCall5321 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25672  7 
     public static final BitSet FOLLOW_expression_in_builtInCall5323 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25673  7 
     public static final BitSet FOLLOW_211_in_builtInCall5325 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25674  7 
     public static final BitSet FOLLOW_expression_in_builtInCall5327 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25675  7 
     public static final BitSet FOLLOW_210_in_builtInCall5329 = new BitSet(new long[]{0x0000000000000002L});
 25676  7 
     public static final BitSet FOLLOW_DATATYPE_in_builtInCall5346 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25677  7 
     public static final BitSet FOLLOW_209_in_builtInCall5348 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25678  7 
     public static final BitSet FOLLOW_expression_in_builtInCall5350 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25679  7 
     public static final BitSet FOLLOW_210_in_builtInCall5352 = new BitSet(new long[]{0x0000000000000002L});
 25680  7 
     public static final BitSet FOLLOW_BOUND_in_builtInCall5368 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25681  7 
     public static final BitSet FOLLOW_209_in_builtInCall5370 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000600L});
 25682  7 
     public static final BitSet FOLLOW_var_in_builtInCall5372 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25683  7 
     public static final BitSet FOLLOW_210_in_builtInCall5374 = new BitSet(new long[]{0x0000000000000002L});
 25684  7 
     public static final BitSet FOLLOW_IRI_in_builtInCall5390 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25685  7 
     public static final BitSet FOLLOW_209_in_builtInCall5392 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25686  7 
     public static final BitSet FOLLOW_expression_in_builtInCall5394 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25687  7 
     public static final BitSet FOLLOW_210_in_builtInCall5396 = new BitSet(new long[]{0x0000000000000002L});
 25688  7 
     public static final BitSet FOLLOW_URI_in_builtInCall5412 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25689  7 
     public static final BitSet FOLLOW_209_in_builtInCall5414 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25690  7 
     public static final BitSet FOLLOW_expression_in_builtInCall5416 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25691  7 
     public static final BitSet FOLLOW_210_in_builtInCall5418 = new BitSet(new long[]{0x0000000000000002L});
 25692  7 
     public static final BitSet FOLLOW_BNODE_in_builtInCall5434 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25693  7 
     public static final BitSet FOLLOW_209_in_builtInCall5437 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25694  7 
     public static final BitSet FOLLOW_expression_in_builtInCall5439 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25695  7 
     public static final BitSet FOLLOW_210_in_builtInCall5441 = new BitSet(new long[]{0x0000000000000002L});
 25696  5 
     public static final BitSet FOLLOW_BNODE_in_builtInCall5458 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25697  5 
     public static final BitSet FOLLOW_nil_in_builtInCall5460 = new BitSet(new long[]{0x0000000000000002L});
 25698  5 
     public static final BitSet FOLLOW_RAND_in_builtInCall5472 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25699  5 
     public static final BitSet FOLLOW_nil_in_builtInCall5474 = new BitSet(new long[]{0x0000000000000002L});
 25700  5 
     public static final BitSet FOLLOW_ABS_in_builtInCall5486 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25701  5 
     public static final BitSet FOLLOW_209_in_builtInCall5488 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25702  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5490 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25703  5 
     public static final BitSet FOLLOW_210_in_builtInCall5492 = new BitSet(new long[]{0x0000000000000002L});
 25704  5 
     public static final BitSet FOLLOW_CEIL_in_builtInCall5508 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25705  5 
     public static final BitSet FOLLOW_209_in_builtInCall5510 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25706  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5512 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25707  5 
     public static final BitSet FOLLOW_210_in_builtInCall5514 = new BitSet(new long[]{0x0000000000000002L});
 25708  5 
     public static final BitSet FOLLOW_FLOOR_in_builtInCall5530 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25709  5 
     public static final BitSet FOLLOW_209_in_builtInCall5532 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25710  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5534 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25711  5 
     public static final BitSet FOLLOW_210_in_builtInCall5536 = new BitSet(new long[]{0x0000000000000002L});
 25712  5 
     public static final BitSet FOLLOW_ROUND_in_builtInCall5552 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25713  5 
     public static final BitSet FOLLOW_209_in_builtInCall5554 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25714  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5556 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25715  5 
     public static final BitSet FOLLOW_210_in_builtInCall5558 = new BitSet(new long[]{0x0000000000000002L});
 25716  5 
     public static final BitSet FOLLOW_CONCAT_in_builtInCall5574 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25717  5 
     public static final BitSet FOLLOW_expressionList_in_builtInCall5576 = new BitSet(new long[]{0x0000000000000002L});
 25718  5 
     public static final BitSet FOLLOW_subStringExpression_in_builtInCall5592 = new BitSet(new long[]{0x0000000000000002L});
 25719  5 
     public static final BitSet FOLLOW_strReplaceExpression_in_builtInCall5604 = new BitSet(new long[]{0x0000000000000002L});
 25720  5 
     public static final BitSet FOLLOW_STRLEN_in_builtInCall5616 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25721  5 
     public static final BitSet FOLLOW_209_in_builtInCall5618 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25722  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5620 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25723  5 
     public static final BitSet FOLLOW_210_in_builtInCall5622 = new BitSet(new long[]{0x0000000000000002L});
 25724  5 
     public static final BitSet FOLLOW_UCASE_in_builtInCall5638 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25725  5 
     public static final BitSet FOLLOW_209_in_builtInCall5640 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25726  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5642 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25727  5 
     public static final BitSet FOLLOW_210_in_builtInCall5644 = new BitSet(new long[]{0x0000000000000002L});
 25728  5 
     public static final BitSet FOLLOW_LCASE_in_builtInCall5660 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25729  5 
     public static final BitSet FOLLOW_209_in_builtInCall5662 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25730  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5664 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25731  5 
     public static final BitSet FOLLOW_210_in_builtInCall5666 = new BitSet(new long[]{0x0000000000000002L});
 25732  5 
     public static final BitSet FOLLOW_ENCODE_FOR_URI_in_builtInCall5682 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25733  5 
     public static final BitSet FOLLOW_209_in_builtInCall5684 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25734  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5686 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25735  5 
     public static final BitSet FOLLOW_210_in_builtInCall5688 = new BitSet(new long[]{0x0000000000000002L});
 25736  5 
     public static final BitSet FOLLOW_CONTAINS_in_builtInCall5704 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25737  5 
     public static final BitSet FOLLOW_209_in_builtInCall5706 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25738  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5708 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25739  5 
     public static final BitSet FOLLOW_211_in_builtInCall5710 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25740  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5712 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25741  5 
     public static final BitSet FOLLOW_210_in_builtInCall5714 = new BitSet(new long[]{0x0000000000000002L});
 25742  5 
     public static final BitSet FOLLOW_STRSTARTS_in_builtInCall5732 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25743  5 
     public static final BitSet FOLLOW_209_in_builtInCall5734 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25744  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5736 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25745  5 
     public static final BitSet FOLLOW_211_in_builtInCall5738 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25746  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5740 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25747  5 
     public static final BitSet FOLLOW_210_in_builtInCall5742 = new BitSet(new long[]{0x0000000000000002L});
 25748  5 
     public static final BitSet FOLLOW_STRENDS_in_builtInCall5760 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25749  5 
     public static final BitSet FOLLOW_209_in_builtInCall5762 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25750  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5764 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25751  5 
     public static final BitSet FOLLOW_211_in_builtInCall5766 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25752  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5768 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25753  5 
     public static final BitSet FOLLOW_210_in_builtInCall5770 = new BitSet(new long[]{0x0000000000000002L});
 25754  5 
     public static final BitSet FOLLOW_STRBEFORE_in_builtInCall5788 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25755  5 
     public static final BitSet FOLLOW_209_in_builtInCall5790 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25756  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5792 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25757  5 
     public static final BitSet FOLLOW_211_in_builtInCall5794 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25758  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5796 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25759  5 
     public static final BitSet FOLLOW_210_in_builtInCall5798 = new BitSet(new long[]{0x0000000000000002L});
 25760  5 
     public static final BitSet FOLLOW_STRAFTER_in_builtInCall5816 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25761  5 
     public static final BitSet FOLLOW_209_in_builtInCall5818 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25762  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5820 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25763  5 
     public static final BitSet FOLLOW_211_in_builtInCall5822 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25764  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5824 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25765  5 
     public static final BitSet FOLLOW_210_in_builtInCall5826 = new BitSet(new long[]{0x0000000000000002L});
 25766  5 
     public static final BitSet FOLLOW_YEAR_in_builtInCall5844 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25767  5 
     public static final BitSet FOLLOW_209_in_builtInCall5846 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25768  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5848 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25769  5 
     public static final BitSet FOLLOW_210_in_builtInCall5850 = new BitSet(new long[]{0x0000000000000002L});
 25770  5 
     public static final BitSet FOLLOW_MONTH_in_builtInCall5866 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25771  5 
     public static final BitSet FOLLOW_209_in_builtInCall5868 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25772  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25773  5 
     public static final BitSet FOLLOW_210_in_builtInCall5872 = new BitSet(new long[]{0x0000000000000002L});
 25774  5 
     public static final BitSet FOLLOW_DAY_in_builtInCall5888 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25775  5 
     public static final BitSet FOLLOW_209_in_builtInCall5890 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25776  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5892 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25777  5 
     public static final BitSet FOLLOW_210_in_builtInCall5894 = new BitSet(new long[]{0x0000000000000002L});
 25778  5 
     public static final BitSet FOLLOW_HOURS_in_builtInCall5910 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25779  5 
     public static final BitSet FOLLOW_209_in_builtInCall5912 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25780  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5914 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25781  5 
     public static final BitSet FOLLOW_210_in_builtInCall5916 = new BitSet(new long[]{0x0000000000000002L});
 25782  5 
     public static final BitSet FOLLOW_MINUTES_in_builtInCall5932 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25783  5 
     public static final BitSet FOLLOW_209_in_builtInCall5934 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25784  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5936 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25785  5 
     public static final BitSet FOLLOW_210_in_builtInCall5938 = new BitSet(new long[]{0x0000000000000002L});
 25786  5 
     public static final BitSet FOLLOW_SECONDS_in_builtInCall5954 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25787  5 
     public static final BitSet FOLLOW_209_in_builtInCall5956 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25788  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5958 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25789  5 
     public static final BitSet FOLLOW_210_in_builtInCall5960 = new BitSet(new long[]{0x0000000000000002L});
 25790  5 
     public static final BitSet FOLLOW_TIMEZONE_in_builtInCall5976 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25791  5 
     public static final BitSet FOLLOW_209_in_builtInCall5978 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25792  5 
     public static final BitSet FOLLOW_expression_in_builtInCall5980 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25793  5 
     public static final BitSet FOLLOW_210_in_builtInCall5982 = new BitSet(new long[]{0x0000000000000002L});
 25794  5 
     public static final BitSet FOLLOW_TZ_in_builtInCall5998 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25795  5 
     public static final BitSet FOLLOW_209_in_builtInCall6000 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25796  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6002 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25797  5 
     public static final BitSet FOLLOW_210_in_builtInCall6004 = new BitSet(new long[]{0x0000000000000002L});
 25798  5 
     public static final BitSet FOLLOW_NOW_in_builtInCall6020 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25799  5 
     public static final BitSet FOLLOW_nil_in_builtInCall6022 = new BitSet(new long[]{0x0000000000000002L});
 25800  5 
     public static final BitSet FOLLOW_MD5_in_builtInCall6034 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25801  5 
     public static final BitSet FOLLOW_209_in_builtInCall6036 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25802  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6038 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25803  5 
     public static final BitSet FOLLOW_210_in_builtInCall6040 = new BitSet(new long[]{0x0000000000000002L});
 25804  5 
     public static final BitSet FOLLOW_SHA1_in_builtInCall6056 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25805  5 
     public static final BitSet FOLLOW_209_in_builtInCall6058 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25806  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6060 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25807  5 
     public static final BitSet FOLLOW_210_in_builtInCall6062 = new BitSet(new long[]{0x0000000000000002L});
 25808  5 
     public static final BitSet FOLLOW_SHA256_in_builtInCall6078 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25809  5 
     public static final BitSet FOLLOW_209_in_builtInCall6080 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25810  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6082 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25811  5 
     public static final BitSet FOLLOW_210_in_builtInCall6084 = new BitSet(new long[]{0x0000000000000002L});
 25812  5 
     public static final BitSet FOLLOW_SHA384_in_builtInCall6100 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25813  5 
     public static final BitSet FOLLOW_209_in_builtInCall6102 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25814  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6104 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25815  5 
     public static final BitSet FOLLOW_210_in_builtInCall6106 = new BitSet(new long[]{0x0000000000000002L});
 25816  5 
     public static final BitSet FOLLOW_SHA512_in_builtInCall6122 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25817  5 
     public static final BitSet FOLLOW_209_in_builtInCall6124 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25818  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6126 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25819  5 
     public static final BitSet FOLLOW_210_in_builtInCall6128 = new BitSet(new long[]{0x0000000000000002L});
 25820  5 
     public static final BitSet FOLLOW_COALESCE_in_builtInCall6144 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25821  5 
     public static final BitSet FOLLOW_expressionList_in_builtInCall6146 = new BitSet(new long[]{0x0000000000000002L});
 25822  5 
     public static final BitSet FOLLOW_IF_in_builtInCall6162 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25823  5 
     public static final BitSet FOLLOW_209_in_builtInCall6164 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25824  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6168 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25825  5 
     public static final BitSet FOLLOW_211_in_builtInCall6170 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25826  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6174 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25827  5 
     public static final BitSet FOLLOW_211_in_builtInCall6176 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25828  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6180 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25829  5 
     public static final BitSet FOLLOW_210_in_builtInCall6182 = new BitSet(new long[]{0x0000000000000002L});
 25830  5 
     public static final BitSet FOLLOW_STRLANG_in_builtInCall6205 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25831  5 
     public static final BitSet FOLLOW_209_in_builtInCall6207 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25832  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6209 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25833  5 
     public static final BitSet FOLLOW_211_in_builtInCall6211 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25834  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6213 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25835  5 
     public static final BitSet FOLLOW_210_in_builtInCall6215 = new BitSet(new long[]{0x0000000000000002L});
 25836  5 
     public static final BitSet FOLLOW_STRDT_in_builtInCall6233 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25837  5 
     public static final BitSet FOLLOW_209_in_builtInCall6235 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25838  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6237 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25839  5 
     public static final BitSet FOLLOW_211_in_builtInCall6239 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25840  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6241 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25841  5 
     public static final BitSet FOLLOW_210_in_builtInCall6243 = new BitSet(new long[]{0x0000000000000002L});
 25842  5 
     public static final BitSet FOLLOW_SAMETERM_in_builtInCall6261 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25843  5 
     public static final BitSet FOLLOW_209_in_builtInCall6263 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25844  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6265 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25845  5 
     public static final BitSet FOLLOW_211_in_builtInCall6267 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25846  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6269 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25847  5 
     public static final BitSet FOLLOW_210_in_builtInCall6271 = new BitSet(new long[]{0x0000000000000002L});
 25848  5 
     public static final BitSet FOLLOW_ISIRI_in_builtInCall6289 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25849  5 
     public static final BitSet FOLLOW_209_in_builtInCall6291 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25850  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6293 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25851  5 
     public static final BitSet FOLLOW_210_in_builtInCall6295 = new BitSet(new long[]{0x0000000000000002L});
 25852  5 
     public static final BitSet FOLLOW_ISURI_in_builtInCall6311 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25853  5 
     public static final BitSet FOLLOW_209_in_builtInCall6313 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25854  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6315 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25855  5 
     public static final BitSet FOLLOW_210_in_builtInCall6317 = new BitSet(new long[]{0x0000000000000002L});
 25856  5 
     public static final BitSet FOLLOW_ISBLANK_in_builtInCall6333 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25857  5 
     public static final BitSet FOLLOW_209_in_builtInCall6335 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25858  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6337 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25859  5 
     public static final BitSet FOLLOW_210_in_builtInCall6339 = new BitSet(new long[]{0x0000000000000002L});
 25860  5 
     public static final BitSet FOLLOW_ISLITERAL_in_builtInCall6356 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25861  5 
     public static final BitSet FOLLOW_209_in_builtInCall6358 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25862  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6360 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25863  5 
     public static final BitSet FOLLOW_210_in_builtInCall6362 = new BitSet(new long[]{0x0000000000000002L});
 25864  5 
     public static final BitSet FOLLOW_ISNUMERIC_in_builtInCall6378 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25865  5 
     public static final BitSet FOLLOW_209_in_builtInCall6380 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25866  5 
     public static final BitSet FOLLOW_expression_in_builtInCall6382 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25867  5 
     public static final BitSet FOLLOW_210_in_builtInCall6384 = new BitSet(new long[]{0x0000000000000002L});
 25868  5 
     public static final BitSet FOLLOW_regexExpression_in_builtInCall6400 = new BitSet(new long[]{0x0000000000000002L});
 25869  5 
     public static final BitSet FOLLOW_existsFunction_in_builtInCall6412 = new BitSet(new long[]{0x0000000000000002L});
 25870  5 
     public static final BitSet FOLLOW_notExistsFunction_in_builtInCall6424 = new BitSet(new long[]{0x0000000000000002L});
 25871  5 
     public static final BitSet FOLLOW_REGEX_in_regexExpression6445 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25872  5 
     public static final BitSet FOLLOW_209_in_regexExpression6447 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25873  5 
     public static final BitSet FOLLOW_expression_in_regexExpression6449 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25874  5 
     public static final BitSet FOLLOW_211_in_regexExpression6451 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25875  5 
     public static final BitSet FOLLOW_expression_in_regexExpression6453 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25876  5 
     public static final BitSet FOLLOW_211_in_regexExpression6456 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25877  5 
     public static final BitSet FOLLOW_expression_in_regexExpression6458 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25878  5 
     public static final BitSet FOLLOW_210_in_regexExpression6462 = new BitSet(new long[]{0x0000000000000002L});
 25879  5 
     public static final BitSet FOLLOW_SUBSTR_in_subStringExpression6492 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25880  5 
     public static final BitSet FOLLOW_209_in_subStringExpression6494 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25881  5 
     public static final BitSet FOLLOW_expression_in_subStringExpression6496 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25882  5 
     public static final BitSet FOLLOW_211_in_subStringExpression6498 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25883  5 
     public static final BitSet FOLLOW_expression_in_subStringExpression6500 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25884  5 
     public static final BitSet FOLLOW_211_in_subStringExpression6503 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25885  5 
     public static final BitSet FOLLOW_expression_in_subStringExpression6505 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25886  5 
     public static final BitSet FOLLOW_210_in_subStringExpression6509 = new BitSet(new long[]{0x0000000000000002L});
 25887  5 
     public static final BitSet FOLLOW_REPLACE_in_strReplaceExpression6543 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25888  5 
     public static final BitSet FOLLOW_209_in_strReplaceExpression6545 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25889  5 
     public static final BitSet FOLLOW_expression_in_strReplaceExpression6547 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25890  5 
     public static final BitSet FOLLOW_211_in_strReplaceExpression6549 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25891  5 
     public static final BitSet FOLLOW_expression_in_strReplaceExpression6551 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25892  5 
     public static final BitSet FOLLOW_211_in_strReplaceExpression6553 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25893  5 
     public static final BitSet FOLLOW_expression_in_strReplaceExpression6555 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25894  5 
     public static final BitSet FOLLOW_211_in_strReplaceExpression6558 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25895  5 
     public static final BitSet FOLLOW_expression_in_strReplaceExpression6560 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25896  5 
     public static final BitSet FOLLOW_210_in_strReplaceExpression6564 = new BitSet(new long[]{0x0000000000000002L});
 25897  5 
     public static final BitSet FOLLOW_EXISTS_in_existsFunction6590 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25898  5 
     public static final BitSet FOLLOW_groupGraphPattern_in_existsFunction6592 = new BitSet(new long[]{0x0000000000000002L});
 25899  5 
     public static final BitSet FOLLOW_NOT_in_notExistsFunction6617 = new BitSet(new long[]{0x2000000000000000L});
 25900  5 
     public static final BitSet FOLLOW_EXISTS_in_notExistsFunction6619 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25901  5 
     public static final BitSet FOLLOW_groupGraphPattern_in_notExistsFunction6621 = new BitSet(new long[]{0x0000000000000002L});
 25902  5 
     public static final BitSet FOLLOW_COUNT_in_aggregate6646 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25903  5 
     public static final BitSet FOLLOW_209_in_aggregate6648 = new BitSet(new long[]{0x24E41F2929818020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25904  5 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6650 = new BitSet(new long[]{0x24E01F2929818020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25905  5 
     public static final BitSet FOLLOW_ASTERISK_in_aggregate6654 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25906  5 
     public static final BitSet FOLLOW_expression_in_aggregate6658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25907  5 
     public static final BitSet FOLLOW_210_in_aggregate6661 = new BitSet(new long[]{0x0000000000000002L});
 25908  5 
     public static final BitSet FOLLOW_SUM_in_aggregate6684 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25909  5 
     public static final BitSet FOLLOW_209_in_aggregate6686 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25910  5 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6688 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25911  5 
     public static final BitSet FOLLOW_expression_in_aggregate6691 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25912  5 
     public static final BitSet FOLLOW_210_in_aggregate6693 = new BitSet(new long[]{0x0000000000000002L});
 25913  5 
     public static final BitSet FOLLOW_MIN_in_aggregate6712 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25914  5 
     public static final BitSet FOLLOW_209_in_aggregate6714 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25915  5 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6716 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25916  5 
     public static final BitSet FOLLOW_expression_in_aggregate6719 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25917  5 
     public static final BitSet FOLLOW_210_in_aggregate6721 = new BitSet(new long[]{0x0000000000000002L});
 25918  5 
     public static final BitSet FOLLOW_MAX_in_aggregate6740 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25919  5 
     public static final BitSet FOLLOW_209_in_aggregate6742 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25920  5 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6744 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25921  5 
     public static final BitSet FOLLOW_expression_in_aggregate6747 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25922  5 
     public static final BitSet FOLLOW_210_in_aggregate6749 = new BitSet(new long[]{0x0000000000000002L});
 25923  5 
     public static final BitSet FOLLOW_AVG_in_aggregate6768 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25924  5 
     public static final BitSet FOLLOW_209_in_aggregate6770 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25925  5 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6772 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25926  5 
     public static final BitSet FOLLOW_expression_in_aggregate6775 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25927  5 
     public static final BitSet FOLLOW_210_in_aggregate6777 = new BitSet(new long[]{0x0000000000000002L});
 25928  5 
     public static final BitSet FOLLOW_SAMPLE_in_aggregate6796 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25929  5 
     public static final BitSet FOLLOW_209_in_aggregate6798 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25930  5 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6800 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25931  5 
     public static final BitSet FOLLOW_expression_in_aggregate6803 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25932  5 
     public static final BitSet FOLLOW_210_in_aggregate6805 = new BitSet(new long[]{0x0000000000000002L});
 25933  5 
     public static final BitSet FOLLOW_GROUP_CONCAT_in_aggregate6824 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25934  5 
     public static final BitSet FOLLOW_209_in_aggregate6826 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25935  5 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6828 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25936  5 
     public static final BitSet FOLLOW_expression_in_aggregate6831 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000140000L});
 25937  5 
     public static final BitSet FOLLOW_212_in_aggregate6834 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 25938  5 
     public static final BitSet FOLLOW_SEPARATOR_in_aggregate6836 = new BitSet(new long[]{0x1000000000000000L});
 25939  5 
     public static final BitSet FOLLOW_EQUAL_in_aggregate6838 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0003C00000000000L});
 25940  5 
     public static final BitSet FOLLOW_string_in_aggregate6840 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25941  5 
     public static final BitSet FOLLOW_210_in_aggregate6844 = new BitSet(new long[]{0x0000000000000002L});
 25942  5 
     public static final BitSet FOLLOW_iriRef_in_iriRefOrFunction6879 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25943  5 
     public static final BitSet FOLLOW_argList_in_iriRefOrFunction6881 = new BitSet(new long[]{0x0000000000000002L});
 25944  5 
     public static final BitSet FOLLOW_string_in_rdfLiteral6914 = new BitSet(new long[]{0x0000000000000002L,0x0000000400000000L,0x0000000000000000L,0x0000000000800000L});
 25945  5 
     public static final BitSet FOLLOW_LANGTAG_in_rdfLiteral6917 = new BitSet(new long[]{0x0000000000000002L});
 25946  5 
     public static final BitSet FOLLOW_215_in_rdfLiteral6922 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25947  5 
     public static final BitSet FOLLOW_iriRef_in_rdfLiteral6924 = new BitSet(new long[]{0x0000000000000002L});
 25948  5 
     public static final BitSet FOLLOW_numericLiteralUnsigned_in_numericLiteral6958 = new BitSet(new long[]{0x0000000000000002L});
 25949  5 
     public static final BitSet FOLLOW_numericLiteralPositive_in_numericLiteral6966 = new BitSet(new long[]{0x0000000000000002L});
 25950  5 
     public static final BitSet FOLLOW_numericLiteralNegative_in_numericLiteral6974 = new BitSet(new long[]{0x0000000000000002L});
 25951  5 
     public static final BitSet FOLLOW_IRI_REF_in_iriRef7157 = new BitSet(new long[]{0x0000000000000002L});
 25952  5 
     public static final BitSet FOLLOW_prefixedName_in_iriRef7165 = new BitSet(new long[]{0x0000000000000002L});
 25953  5 
     public static final BitSet FOLLOW_BLANK_NODE_LABEL_in_blankNode7207 = new BitSet(new long[]{0x0000000000000002L});
 25954  5 
     public static final BitSet FOLLOW_anon_in_blankNode7215 = new BitSet(new long[]{0x0000000000000002L});
 25955  5 
     public static final BitSet FOLLOW_213_in_anon7232 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000400000L});
 25956  5 
     public static final BitSet FOLLOW_214_in_anon7234 = new BitSet(new long[]{0x0000000000000002L});
 25957   
 
 25958   
 }
Report generated by Cobertura 1.9.4.1 on 17.03.12 19:46.